295 lines
8.5 KiB
Java
295 lines
8.5 KiB
Java
package appeng.client.render.crafting;
|
|
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.Collections;
|
|
import java.util.EnumSet;
|
|
import java.util.List;
|
|
import javax.annotation.Nullable;
|
|
|
|
import net.minecraft.block.state.IBlockState;
|
|
import net.minecraft.client.renderer.block.model.BakedQuad;
|
|
import net.minecraft.client.renderer.block.model.IBakedModel;
|
|
import net.minecraft.client.renderer.block.model.ItemCameraTransforms;
|
|
import net.minecraft.client.renderer.block.model.ItemOverrideList;
|
|
import net.minecraft.client.renderer.texture.TextureAtlasSprite;
|
|
import net.minecraft.client.renderer.vertex.VertexFormat;
|
|
import net.minecraft.util.EnumFacing;
|
|
import net.minecraftforge.common.property.IExtendedBlockState;
|
|
|
|
import appeng.block.crafting.BlockCraftingUnit;
|
|
import appeng.client.render.cablebus.CubeBuilder;
|
|
|
|
|
|
/**
|
|
* The base model for baked models used by components of the crafting cube multi-block in it's formed state.
|
|
* Primarily this base class handles adding the "ring" that frames the multi-block structure and delegates
|
|
* rendering of the "inner" part of each block to the subclasses of this class.
|
|
*/
|
|
abstract class CraftingCubeBakedModel implements IBakedModel
|
|
{
|
|
|
|
private final VertexFormat format;
|
|
|
|
private final TextureAtlasSprite ringCorner;
|
|
|
|
private final TextureAtlasSprite ringHor;
|
|
|
|
private final TextureAtlasSprite ringVer;
|
|
|
|
CraftingCubeBakedModel( VertexFormat format, TextureAtlasSprite ringCorner, TextureAtlasSprite ringHor, TextureAtlasSprite ringVer )
|
|
{
|
|
this.format = format;
|
|
this.ringCorner = ringCorner;
|
|
this.ringHor = ringHor;
|
|
this.ringVer = ringVer;
|
|
}
|
|
|
|
@Override
|
|
public List<BakedQuad> getQuads( @Nullable IBlockState state, @Nullable EnumFacing side, long rand )
|
|
{
|
|
|
|
if( side == null )
|
|
{
|
|
return Collections.emptyList(); // No generic quads for this model
|
|
}
|
|
|
|
EnumSet<EnumFacing> connections = getConnections( state );
|
|
|
|
List<BakedQuad> quads = new ArrayList<>();
|
|
CubeBuilder builder = new CubeBuilder( format, quads );
|
|
|
|
builder.setDrawFaces( EnumSet.of( side ) );
|
|
|
|
// Add the quads for the ring that frames the entire multi-block structure
|
|
addRing( builder, side, connections );
|
|
|
|
// Calculate the bounds of the "inner" block that is framed by the border drawn above
|
|
float x2 = connections.contains( EnumFacing.EAST ) ? 16 : 13.01f;
|
|
float x1 = connections.contains( EnumFacing.WEST ) ? 0 : 2.99f;
|
|
|
|
float y2 = connections.contains( EnumFacing.UP ) ? 16 : 13.01f;
|
|
float y1 = connections.contains( EnumFacing.DOWN ) ? 0 : 2.99f;
|
|
|
|
float z2 = connections.contains( EnumFacing.SOUTH ) ? 16 : 13.01f;
|
|
float z1 = connections.contains( EnumFacing.NORTH ) ? 0 : 2.99f;
|
|
|
|
// On the axis of the side that we're currently drawing, extend the dimensions
|
|
// out to the outer face of the block
|
|
switch( side )
|
|
{
|
|
case DOWN:
|
|
case UP:
|
|
y1 = 0;
|
|
y2 = 16;
|
|
break;
|
|
case NORTH:
|
|
case SOUTH:
|
|
z1 = 0;
|
|
z2 = 16;
|
|
break;
|
|
case WEST:
|
|
case EAST:
|
|
x1 = 0;
|
|
x2 = 16;
|
|
break;
|
|
}
|
|
|
|
addInnerCube( side, state, builder, x1, y1, z1, x2, y2, z2 );
|
|
|
|
return quads;
|
|
}
|
|
|
|
private void addRing( CubeBuilder builder, @Nullable EnumFacing side, EnumSet<EnumFacing> connections )
|
|
{
|
|
// Fill in the corners
|
|
builder.setTexture( ringCorner );
|
|
addCornerCap( builder, connections, side, EnumFacing.UP, EnumFacing.EAST, EnumFacing.NORTH );
|
|
addCornerCap( builder, connections, side, EnumFacing.UP, EnumFacing.EAST, EnumFacing.SOUTH );
|
|
addCornerCap( builder, connections, side, EnumFacing.UP, EnumFacing.WEST, EnumFacing.NORTH );
|
|
addCornerCap( builder, connections, side, EnumFacing.UP, EnumFacing.WEST, EnumFacing.SOUTH );
|
|
addCornerCap( builder, connections, side, EnumFacing.DOWN, EnumFacing.EAST, EnumFacing.NORTH );
|
|
addCornerCap( builder, connections, side, EnumFacing.DOWN, EnumFacing.EAST, EnumFacing.SOUTH );
|
|
addCornerCap( builder, connections, side, EnumFacing.DOWN, EnumFacing.WEST, EnumFacing.NORTH );
|
|
addCornerCap( builder, connections, side, EnumFacing.DOWN, EnumFacing.WEST, EnumFacing.SOUTH );
|
|
|
|
// Fill in the remaining stripes of the face
|
|
for( EnumFacing a : EnumFacing.values() )
|
|
{
|
|
if( a == side || a == side.getOpposite() )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// Select the horizontal or vertical ring texture depending on which side we're filling in
|
|
if( ( side.getAxis() != EnumFacing.Axis.Y ) && ( a == EnumFacing.NORTH || a == EnumFacing.EAST || a == EnumFacing.WEST || a == EnumFacing.SOUTH ) )
|
|
{
|
|
builder.setTexture( ringVer );
|
|
}
|
|
else if( side.getAxis() == EnumFacing.Axis.Y && ( a == EnumFacing.EAST || a == EnumFacing.WEST ) )
|
|
{
|
|
builder.setTexture( ringVer );
|
|
}
|
|
else
|
|
{
|
|
builder.setTexture( ringHor );
|
|
}
|
|
|
|
// If there's an adjacent crafting cube block on side a, then the core of the block already extends
|
|
// fully to this side. So only bother drawing the stripe, if there's no connection.
|
|
if( !connections.contains( a ) )
|
|
{
|
|
// Note that since we're drawing something that "looks" 2-dimensional,
|
|
// two of the following will always be 0 and 16.
|
|
float x1 = 0, y1 = 0, z1 = 0, x2 = 16, y2 = 16, z2 = 16;
|
|
|
|
switch( a )
|
|
{
|
|
case DOWN:
|
|
y1 = 0;
|
|
y2 = 3;
|
|
break;
|
|
case UP:
|
|
y1 = 13.0f;
|
|
y2 = 16;
|
|
break;
|
|
case WEST:
|
|
x1 = 0;
|
|
x2 = 3;
|
|
break;
|
|
case EAST:
|
|
x1 = 13;
|
|
x2 = 16;
|
|
break;
|
|
case NORTH:
|
|
z1 = 0;
|
|
z2 = 3;
|
|
break;
|
|
case SOUTH:
|
|
z1 = 13;
|
|
z2 = 16;
|
|
break;
|
|
}
|
|
|
|
// Constraint the stripe in the two directions perpendicular to a in case there has been a corner
|
|
// drawn in those directions. Since a corner is drawn if the three touching faces dont have adjacent
|
|
// crafting cube blocks, we'd have to check for a, side, and the perpendicular direction. But in this
|
|
// block, we've already checked for side (due to face culling) and a (see above).
|
|
EnumFacing perpendicular = a.rotateAround( side.getAxis() );
|
|
for ( EnumFacing cornerCandidate: EnumSet.of(perpendicular, perpendicular.getOpposite()))
|
|
{
|
|
if( !connections.contains( cornerCandidate ) )
|
|
{
|
|
// There's a cap in this direction
|
|
switch( cornerCandidate )
|
|
{
|
|
case DOWN:
|
|
y1 = 3;
|
|
break;
|
|
case UP:
|
|
y2 = 13;
|
|
break;
|
|
case NORTH:
|
|
z1 = 3;
|
|
break;
|
|
case SOUTH:
|
|
z2 = 13;
|
|
break;
|
|
case WEST:
|
|
x1 = 3;
|
|
break;
|
|
case EAST:
|
|
x2 = 13;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
builder.addCube( x1, y1, z1, x2, y2, z2 );
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Adds a 3x3x3 corner cap to the cube builder if there are no adjacent crafting cubes on that corner.
|
|
*/
|
|
private void addCornerCap( CubeBuilder builder, EnumSet<EnumFacing> connections, EnumFacing side, EnumFacing down, EnumFacing west, EnumFacing north )
|
|
{
|
|
if( connections.contains( down ) || connections.contains( west ) || connections.contains( north ) )
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Only add faces for sides that can actually be seen (the outside of the cube)
|
|
if( side != down && side != west && side != north )
|
|
{
|
|
return;
|
|
}
|
|
|
|
float x1 = (west == EnumFacing.WEST ? 0 : 13);
|
|
float y1 = (down == EnumFacing.DOWN ? 0 : 13);
|
|
float z1 = (north == EnumFacing.NORTH ? 0 : 13);
|
|
float x2 = (west == EnumFacing.WEST ? 3 : 16);
|
|
float y2 = (down == EnumFacing.DOWN ? 3 : 16);
|
|
float z2 = (north == EnumFacing.NORTH ? 3 : 16);
|
|
builder.addCube( x1, y1, z1, x2, y2, z2 );
|
|
}
|
|
|
|
// Retrieve the cube connection state from the block state
|
|
// If none is present, just assume there are no adjacent crafting cube blocks
|
|
private static EnumSet<EnumFacing> getConnections( @Nullable IBlockState state )
|
|
{
|
|
if( !( state instanceof IExtendedBlockState ) )
|
|
{
|
|
return EnumSet.noneOf( EnumFacing.class );
|
|
}
|
|
|
|
IExtendedBlockState extState = (IExtendedBlockState) state;
|
|
CraftingCubeState cubeState = extState.getValue( BlockCraftingUnit.STATE );
|
|
if( cubeState == null )
|
|
{
|
|
return EnumSet.noneOf( EnumFacing.class );
|
|
}
|
|
|
|
return cubeState.getConnections();
|
|
}
|
|
|
|
protected abstract void addInnerCube( EnumFacing facing, IBlockState state, CubeBuilder builder, float x1, float y1, float z1, float x2, float y2, float z2 );
|
|
|
|
@Override
|
|
public boolean isAmbientOcclusion()
|
|
{
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public boolean isGui3d()
|
|
{
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public boolean isBuiltInRenderer()
|
|
{
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public TextureAtlasSprite getParticleTexture()
|
|
{
|
|
return ringCorner;
|
|
}
|
|
|
|
@Override
|
|
public ItemCameraTransforms getItemCameraTransforms()
|
|
{
|
|
return ItemCameraTransforms.DEFAULT;
|
|
}
|
|
|
|
@Override
|
|
public ItemOverrideList getOverrides()
|
|
{
|
|
return ItemOverrideList.NONE;
|
|
}
|
|
}
|