Separate render rewrite

Author: M-W-K

src/main/java/gregtech/api/block/UnlistedByteProperty.java

@@ -0,0 +1,36 @@
+package gregtech.api.block;
+
+import net.minecraftforge.common.property.IUnlistedProperty;
+
+import org.jetbrains.annotations.NotNull;
+
+public class UnlistedByteProperty implements IUnlistedProperty<Byte> {
+
+    private final String name;
+
+    public UnlistedByteProperty(@NotNull String name) {
+        this.name = name;
+    }
+
+    @NotNull
+    @Override
+    public String getName() {
+        return this.name;
+    }
+
+    @Override
+    public boolean isValid(Byte value) {
+        return true;
+    }
+
+    @NotNull
+    @Override
+    public Class<Byte> getType() {
+        return Byte.class;
+    }
+
+    @Override
+    public String valueToString(@NotNull Byte value) {
+        return value.toString();
+    }
+}

src/main/java/gregtech/api/block/UnlistedFloatProperty.java

@@ -0,0 +1,36 @@
+package gregtech.api.block;
+
+import net.minecraftforge.common.property.IUnlistedProperty;
+
+import org.jetbrains.annotations.NotNull;
+
+public class UnlistedFloatProperty implements IUnlistedProperty<Float> {
+
+    private final String name;
+
+    public UnlistedFloatProperty(@NotNull String name) {
+        this.name = name;
+    }
+
+    @NotNull
+    @Override
+    public String getName() {
+        return this.name;
+    }
+
+    @Override
+    public boolean isValid(Float value) {
+        return true;
+    }
+
+    @NotNull
+    @Override
+    public Class<Float> getType() {
+        return Float.class;
+    }
+
+    @Override
+    public String valueToString(@NotNull Float value) {
+        return value.toString();
+    }
+}

src/main/java/gregtech/api/block/UnlistedPropertyMaterial.java

@@ -0,0 +1,37 @@
+package gregtech.api.block;
+
+import gregtech.api.unification.material.Material;
+
+import net.minecraftforge.common.property.IUnlistedProperty;
+
+import org.jetbrains.annotations.NotNull;
+
+public class UnlistedPropertyMaterial implements IUnlistedProperty<Material> {
+
+    private final String name;
+
+    public UnlistedPropertyMaterial(@NotNull String name) {
+        this.name = name;
+    }
+
+    @NotNull
+    @Override
+    public String getName() {
+        return name;
+    }
+
+    @Override
+    public boolean isValid(Material value) {
+        return true;
+    }
+
+    @Override
+    public Class<Material> getType() {
+        return Material.class;
+    }
+
+    @Override
+    public String valueToString(Material value) {
+        return value.toString();
+    }
+}

src/main/java/gregtech/api/cover/Cover.java

@@ -1,5 +1,6 @@
 package gregtech.api.cover;
 
+import gregtech.client.renderer.pipe.cover.CoverRenderer;
 import gregtech.client.utils.BloomEffectUtil;
 
 import net.minecraft.entity.player.EntityPlayer;
@@ -248,6 +249,10 @@ void renderCoverPlate(@NotNull CCRenderState renderState, @NotNull Matrix4 trans
                           @NotNull IVertexOperation[] pipeline,
                           @NotNull Cuboid6 plateBox, @NotNull BlockRenderLayer layer);
 
+    @SideOnly(Side.CLIENT)
+    @NotNull
+    CoverRenderer getRenderer();
+
     default boolean canRenderBackside() {
         return true;
     }

src/main/java/gregtech/api/cover/CoverBase.java

@@ -2,6 +2,7 @@
 
 import gregtech.api.GTValues;
 import gregtech.api.metatileentity.MetaTileEntity;
+import gregtech.client.renderer.pipe.cover.CoverRenderer;
 import gregtech.client.renderer.texture.Textures;
 import gregtech.client.renderer.texture.cube.SimpleSidedCubeRenderer;
 
@@ -19,6 +20,7 @@
 import codechicken.lib.vec.Cuboid6;
 import codechicken.lib.vec.Matrix4;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -29,6 +31,9 @@ public abstract class CoverBase implements Cover {
     private final CoverableView coverableView;
     private final EnumFacing attachedSide;
 
+    @SideOnly(Side.CLIENT)
+    protected @Nullable CoverRenderer renderer;
+
     public CoverBase(@NotNull CoverDefinition definition, @NotNull CoverableView coverableView,
                      @NotNull EnumFacing attachedSide) {
         this.definition = definition;
@@ -79,6 +84,15 @@ public void renderCoverPlate(@NotNull CCRenderState renderState, @NotNull Matrix
         }
     }
 
+    @Override
+    @SideOnly(Side.CLIENT)
+    public @NotNull CoverRenderer getRenderer() {
+        if (renderer == null) renderer = buildRenderer();
+        return renderer;
+    }
+
+    protected abstract CoverRenderer buildRenderer();
+
     @SideOnly(Side.CLIENT)
     protected @NotNull TextureAtlasSprite getPlateSprite() {
         return Textures.VOLTAGE_CASINGS[GTValues.LV].getSpriteOnSide(SimpleSidedCubeRenderer.RenderSide.SIDE);

src/main/java/gregtech/api/pipenet/block/BlockPipe.java

@@ -14,6 +14,8 @@
 import gregtech.api.pipenet.tile.PipeCoverableImplementation;
 import gregtech.api.pipenet.tile.TileEntityPipeBase;
 import gregtech.api.util.GTUtility;
+import gregtech.client.renderer.pipe.PipeRenderProperties;
+import gregtech.client.renderer.pipe.cover.CoverRendererPackage;
 import gregtech.common.ConfigHolder;
 import gregtech.common.blocks.BlockFrame;
 import gregtech.common.blocks.MetaBlocks;
@@ -23,9 +25,12 @@
 import net.minecraft.block.Block;
 import net.minecraft.block.ITileEntityProvider;
 import net.minecraft.block.SoundType;
+import net.minecraft.block.properties.PropertyBool;
 import net.minecraft.block.state.BlockFaceShape;
+import net.minecraft.block.state.BlockStateContainer;
 import net.minecraft.block.state.IBlockState;
 import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.texture.TextureAtlasSprite;
 import net.minecraft.creativetab.CreativeTabs;
 import net.minecraft.entity.Entity;
 import net.minecraft.entity.EntityLivingBase;
@@ -46,18 +51,21 @@
 import net.minecraft.util.math.Vec3d;
 import net.minecraft.world.IBlockAccess;
 import net.minecraft.world.World;
+import net.minecraftforge.common.property.IExtendedBlockState;
 import net.minecraftforge.fml.relauncher.Side;
 import net.minecraftforge.fml.relauncher.SideOnly;
 
 import codechicken.lib.raytracer.CuboidRayTraceResult;
 import codechicken.lib.raytracer.IndexedCuboid6;
 import codechicken.lib.raytracer.RayTracer;
 import codechicken.lib.vec.Cuboid6;
+import org.apache.commons.lang3.tuple.Pair;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.ArrayList;
 import java.util.Collections;
+import java.util.EnumMap;
 import java.util.List;
 import java.util.Random;
 
@@ -68,6 +76,28 @@ public abstract class BlockPipe<PipeType extends Enum<PipeType> & IPipeType<Node
         WorldPipeNetType extends WorldPipeNet<NodeDataType, ? extends PipeNet<NodeDataType>>> extends BuiltInRenderBlock
                                implements ITileEntityProvider, IFacadeWrapper, IBlockAppearance {
 
+    public static final PropertyBool NORTH = PropertyBool.create("north");
+    public static final PropertyBool EAST = PropertyBool.create("east");
+    public static final PropertyBool SOUTH = PropertyBool.create("south");
+    public static final PropertyBool WEST = PropertyBool.create("west");
+    public static final PropertyBool UP = PropertyBool.create("up");
+    public static final PropertyBool DOWN = PropertyBool.create("down");
+
+    public static final EnumMap<EnumFacing, PropertyBool> FACINGS = buildFacings();
+
+    private static @NotNull EnumMap<EnumFacing, PropertyBool> buildFacings() {
+        EnumMap<EnumFacing, PropertyBool> map = new EnumMap<>(EnumFacing.class);
+        map.put(EnumFacing.NORTH, NORTH);
+        map.put(EnumFacing.EAST, EAST);
+        map.put(EnumFacing.SOUTH, SOUTH);
+        map.put(EnumFacing.WEST, WEST);
+        map.put(EnumFacing.UP, UP);
+        map.put(EnumFacing.DOWN, DOWN);
+        return map;
+    }
+
+    public static final PropertyBool FRAMED = PropertyBool.create("framed");
+
     protected final ThreadLocal<IPipeTile<PipeType, NodeDataType>> tileEntities = new ThreadLocal<>();
 
     public BlockPipe() {
@@ -146,7 +176,7 @@ public ItemStack getItem(@NotNull World world, @NotNull BlockPos pos, @NotNull I
     protected abstract NodeDataType getFallbackType();
 
     // TODO this has no reason to need an ItemStack parameter
-    public abstract PipeType getItemPipeType(ItemStack itemStack);
+    public abstract PipeType getPipeType();
 
     public abstract void setTileEntityData(TileEntityPipeBase<PipeType, NodeDataType> pipeTile, ItemStack itemStack);
 
@@ -352,7 +382,7 @@ public boolean onPipeActivated(World world, IBlockState state, BlockPos pos, Ent
             IBlockState blockStateAtSide = world.getBlockState(pos.offset(side));
             if (blockStateAtSide.getBlock() instanceof BlockFrame) {
                 ItemBlockPipe<?, ?> itemBlockPipe = (ItemBlockPipe<?, ?>) itemStack.getItem();
-                if (itemBlockPipe.blockPipe.getItemPipeType(itemStack) == getItemPipeType(itemStack)) {
+                if (itemBlockPipe.blockPipe.getPipeType() == getPipeType()) {
                     BlockFrame frameBlock = (BlockFrame) blockStateAtSide.getBlock();
                     boolean wasPlaced = frameBlock.replaceWithFramedPipe(world, pos.offset(side), blockStateAtSide,
                             entityPlayer, itemStack, side);
@@ -734,4 +764,68 @@ public PipeConnectionData(EnumFacing side) {
             this.side = side;
         }
     }
+
+    @Override
+    public int getMetaFromState(@NotNull IBlockState state) {
+        return 0;
+    }
+
+    @Override
+    protected @NotNull BlockStateContainer createBlockState() {
+        return constructState(new BlockStateContainer.Builder(this))
+                .add(NORTH, SOUTH, EAST, WEST, UP, DOWN, FRAMED)
+                .build();
+    }
+
+    protected @NotNull BlockStateContainer.Builder constructState(BlockStateContainer.@NotNull Builder builder) {
+        return builder.add(PipeRenderProperties.THICKNESS_PROPERTY).add(PipeRenderProperties.CLOSED_MASK_PROPERTY)
+                .add(PipeRenderProperties.BLOCKED_MASK_PROPERTY).add(PipeRenderProperties.COLOR_PROPERTY)
+                .add(PipeRenderProperties.FRAME_MATERIAL_PROPERTY).add(PipeRenderProperties.FRAME_MASK_PROPERTY)
+                .add(CoverRendererPackage.CRP_PROPERTY);
+    }
+
+    @SuppressWarnings("deprecation")
+    @Override
+    public @NotNull IBlockState getActualState(@NotNull IBlockState state, @NotNull IBlockAccess worldIn,
+                                               @NotNull BlockPos pos) {
+        var tile = getPipeTileEntity(worldIn, pos);
+        if (tile == null) return state;
+        state = writeConnectionMask(state, tile.getCoverAdjustedConnectionMask());
+        return state.withProperty(FRAMED, tile.getFrameMaterial() != null);
+    }
+
+    public static IBlockState writeConnectionMask(@NotNull IBlockState state, byte connectionMask) {
+        for (EnumFacing facing : EnumFacing.VALUES) {
+            state = state.withProperty(FACINGS.get(facing), GTUtility.evalMask(facing, connectionMask));
+        }
+        return state;
+    }
+
+    public static byte readConnectionMask(@NotNull IBlockState state) {
+        byte mask = 0;
+        for (EnumFacing facing : EnumFacing.VALUES) {
+            if (state.getValue(FACINGS.get(facing))) {
+                mask |= (byte) (1 << facing.ordinal());
+            }
+        }
+        return mask;
+    }
+
+    @Override
+    public @NotNull IBlockState getExtendedState(@NotNull IBlockState state, @NotNull IBlockAccess world,
+                                                 @NotNull BlockPos pos) {
+        var tile = getPipeTileEntity(world, pos);
+        if (tile == null) return state;
+        else return tile.getRenderInformation((IExtendedBlockState) state.getActualState(world, pos));
+    }
+
+    @SideOnly(Side.CLIENT)
+    @Override
+    protected Pair<TextureAtlasSprite, Integer> getParticleTexture(World world, BlockPos blockPos) {
+        var tile = getPipeTileEntity(world, blockPos);
+        if (tile != null) {
+            return getPipeType().getModel().getParticleTexture(tile.getPaintingColor(), null);
+        }
+        return null;
+    }
 }

src/main/java/gregtech/api/pipenet/block/IPipeType.java

@@ -1,6 +1,10 @@
 package gregtech.api.pipenet.block;
 
+import gregtech.client.renderer.pipe.PipeModelRedirector;
+
 import net.minecraft.util.IStringSerializable;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
 
 public interface IPipeType<NodeDataType> extends IStringSerializable {
 
@@ -9,4 +13,7 @@ public interface IPipeType<NodeDataType> extends IStringSerializable {
     NodeDataType modifyProperties(NodeDataType baseProperties);
 
     boolean isPaintable();
+
+    @SideOnly(Side.CLIENT)
+    PipeModelRedirector getModel();
 }

src/main/java/gregtech/api/pipenet/block/ItemBlockPipe.java

@@ -24,6 +24,11 @@ public ItemBlockPipe(BlockPipe<PipeType, NodeDataType, ?> block) {
         setHasSubtypes(true);
     }
 
+    @Override
+    public @NotNull BlockPipe<PipeType, NodeDataType, ?> getBlock() {
+        return (BlockPipe<PipeType, NodeDataType, ?>) super.getBlock();
+    }
+
     @Override
     public int getMetadata(int damage) {
         return damage;