mirror of
http://git.eaglercraft.rip/eaglercraft/eaglercraft-1.8.git
synced 2025-04-30 02:01:59 -05:00
2100 lines
68 KiB
Java
2100 lines
68 KiB
Java
package net.optifine;
|
|
|
|
import java.io.FileNotFoundException;
|
|
import java.io.InputStream;
|
|
import java.util.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.Collections;
|
|
import java.util.EnumMap;
|
|
import java.util.HashSet;
|
|
import java.util.IdentityHashMap;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.Properties;
|
|
import java.util.Set;
|
|
|
|
import net.lax1dude.eaglercraft.v1_8.minecraft.EaglerTextureAtlasSprite;
|
|
import net.minecraft.block.Block;
|
|
import net.minecraft.block.BlockGlass;
|
|
import net.minecraft.block.BlockPane;
|
|
import net.minecraft.block.BlockQuartz;
|
|
import net.minecraft.block.BlockRotatedPillar;
|
|
import net.minecraft.block.BlockStainedGlass;
|
|
import net.minecraft.block.BlockStainedGlassPane;
|
|
import net.minecraft.block.state.BlockStateBase;
|
|
import net.minecraft.block.state.IBlockState;
|
|
import net.minecraft.client.Minecraft;
|
|
import net.minecraft.client.renderer.block.model.BakedQuad;
|
|
import net.minecraft.client.renderer.texture.TextureMap;
|
|
import net.minecraft.client.resources.IResourcePack;
|
|
import net.minecraft.client.resources.model.IBakedModel;
|
|
import net.minecraft.init.Blocks;
|
|
import net.minecraft.util.BlockPos;
|
|
import net.minecraft.util.EnumFacing;
|
|
import net.minecraft.util.ResourceLocation;
|
|
import net.minecraft.world.IBlockAccess;
|
|
import net.minecraft.world.biome.BiomeGenBase;
|
|
import net.optifine.config.Matches;
|
|
import net.optifine.model.BlockModelUtils;
|
|
import net.optifine.model.ListQuadsOverlay;
|
|
import net.optifine.render.RenderEnv;
|
|
import net.optifine.util.PropertiesOrdered;
|
|
import net.optifine.util.ResUtils;
|
|
import net.optifine.util.TileEntityUtils;
|
|
|
|
public class ConnectedTextures {
|
|
private static Map[] spriteQuadMaps = null;
|
|
private static Map[] spriteQuadFullMaps = null;
|
|
private static Map[][] spriteQuadCompactMaps = (Map[][]) null;
|
|
private static ConnectedProperties[][] blockProperties = (ConnectedProperties[][]) null;
|
|
private static ConnectedProperties[][] tileProperties = (ConnectedProperties[][]) null;
|
|
private static boolean multipass = false;
|
|
protected static final int UNKNOWN = -1;
|
|
protected static final int Y_NEG_DOWN = 0;
|
|
protected static final int Y_POS_UP = 1;
|
|
protected static final int Z_NEG_NORTH = 2;
|
|
protected static final int Z_POS_SOUTH = 3;
|
|
protected static final int X_NEG_WEST = 4;
|
|
protected static final int X_POS_EAST = 5;
|
|
private static final int Y_AXIS = 0;
|
|
private static final int Z_AXIS = 1;
|
|
private static final int X_AXIS = 2;
|
|
public static final IBlockState AIR_DEFAULT_STATE = Blocks.air.getDefaultState();
|
|
private static EaglerTextureAtlasSprite emptySprite = null;
|
|
private static final BlockDir[] SIDES_Y_NEG_DOWN = new BlockDir[] { BlockDir.WEST, BlockDir.EAST, BlockDir.NORTH,
|
|
BlockDir.SOUTH };
|
|
private static final BlockDir[] SIDES_Y_POS_UP = new BlockDir[] { BlockDir.WEST, BlockDir.EAST, BlockDir.SOUTH,
|
|
BlockDir.NORTH };
|
|
private static final BlockDir[] SIDES_Z_NEG_NORTH = new BlockDir[] { BlockDir.EAST, BlockDir.WEST, BlockDir.DOWN,
|
|
BlockDir.UP };
|
|
private static final BlockDir[] SIDES_Z_POS_SOUTH = new BlockDir[] { BlockDir.WEST, BlockDir.EAST, BlockDir.DOWN,
|
|
BlockDir.UP };
|
|
private static final BlockDir[] SIDES_X_NEG_WEST = new BlockDir[] { BlockDir.NORTH, BlockDir.SOUTH, BlockDir.DOWN,
|
|
BlockDir.UP };
|
|
private static final BlockDir[] SIDES_X_POS_EAST = new BlockDir[] { BlockDir.SOUTH, BlockDir.NORTH, BlockDir.DOWN,
|
|
BlockDir.UP };
|
|
private static final BlockDir[] SIDES_Z_NEG_NORTH_Z_AXIS = new BlockDir[] { BlockDir.WEST, BlockDir.EAST,
|
|
BlockDir.UP, BlockDir.DOWN };
|
|
private static final BlockDir[] SIDES_X_POS_EAST_X_AXIS = new BlockDir[] { BlockDir.NORTH, BlockDir.SOUTH,
|
|
BlockDir.UP, BlockDir.DOWN };
|
|
private static final BlockDir[] EDGES_Y_NEG_DOWN = new BlockDir[] { BlockDir.NORTH_EAST, BlockDir.NORTH_WEST,
|
|
BlockDir.SOUTH_EAST, BlockDir.SOUTH_WEST };
|
|
private static final BlockDir[] EDGES_Y_POS_UP = new BlockDir[] { BlockDir.SOUTH_EAST, BlockDir.SOUTH_WEST,
|
|
BlockDir.NORTH_EAST, BlockDir.NORTH_WEST };
|
|
private static final BlockDir[] EDGES_Z_NEG_NORTH = new BlockDir[] { BlockDir.DOWN_WEST, BlockDir.DOWN_EAST,
|
|
BlockDir.UP_WEST, BlockDir.UP_EAST };
|
|
private static final BlockDir[] EDGES_Z_POS_SOUTH = new BlockDir[] { BlockDir.DOWN_EAST, BlockDir.DOWN_WEST,
|
|
BlockDir.UP_EAST, BlockDir.UP_WEST };
|
|
private static final BlockDir[] EDGES_X_NEG_WEST = new BlockDir[] { BlockDir.DOWN_SOUTH, BlockDir.DOWN_NORTH,
|
|
BlockDir.UP_SOUTH, BlockDir.UP_NORTH };
|
|
private static final BlockDir[] EDGES_X_POS_EAST = new BlockDir[] { BlockDir.DOWN_NORTH, BlockDir.DOWN_SOUTH,
|
|
BlockDir.UP_NORTH, BlockDir.UP_SOUTH };
|
|
private static final BlockDir[] EDGES_Z_NEG_NORTH_Z_AXIS = new BlockDir[] { BlockDir.UP_EAST, BlockDir.UP_WEST,
|
|
BlockDir.DOWN_EAST, BlockDir.DOWN_WEST };
|
|
private static final BlockDir[] EDGES_X_POS_EAST_X_AXIS = new BlockDir[] { BlockDir.UP_SOUTH, BlockDir.UP_NORTH,
|
|
BlockDir.DOWN_SOUTH, BlockDir.DOWN_NORTH };
|
|
public static final EaglerTextureAtlasSprite SPRITE_DEFAULT = new EaglerTextureAtlasSprite("<default>");
|
|
|
|
public static BakedQuad[] getConnectedTexture(IBlockAccess blockAccess, IBlockState blockState, BlockPos blockPos,
|
|
BakedQuad quad, RenderEnv renderEnv) {
|
|
EaglerTextureAtlasSprite textureatlassprite = quad.getSprite();
|
|
|
|
if (textureatlassprite == null) {
|
|
return renderEnv.getArrayQuadsCtm(quad);
|
|
} else {
|
|
Block block = blockState.getBlock();
|
|
|
|
if (skipConnectedTexture(blockAccess, blockState, blockPos, quad, renderEnv)) {
|
|
quad = getQuad(emptySprite, quad);
|
|
return renderEnv.getArrayQuadsCtm(quad);
|
|
} else {
|
|
EnumFacing enumfacing = quad.getFace();
|
|
BakedQuad[] abakedquad = getConnectedTextureMultiPass(blockAccess, blockState, blockPos, enumfacing,
|
|
quad, renderEnv);
|
|
return abakedquad;
|
|
}
|
|
}
|
|
}
|
|
|
|
private static boolean skipConnectedTexture(IBlockAccess blockAccess, IBlockState blockState, BlockPos blockPos,
|
|
BakedQuad quad, RenderEnv renderEnv) {
|
|
Block block = blockState.getBlock();
|
|
|
|
if (block instanceof BlockPane) {
|
|
EaglerTextureAtlasSprite textureatlassprite = quad.getSprite();
|
|
|
|
if (textureatlassprite.getIconName().startsWith("minecraft:blocks/glass_pane_top")) {
|
|
IBlockState iblockstate1 = blockAccess.getBlockState(blockPos.offset(quad.getFace()));
|
|
return iblockstate1 == blockState;
|
|
}
|
|
}
|
|
|
|
if (block instanceof BlockPane) {
|
|
EnumFacing enumfacing = quad.getFace();
|
|
|
|
if (enumfacing != EnumFacing.UP && enumfacing != EnumFacing.DOWN) {
|
|
return false;
|
|
}
|
|
|
|
if (!quad.isFaceQuad()) {
|
|
return false;
|
|
}
|
|
|
|
BlockPos blockpos = blockPos.offset(quad.getFace());
|
|
IBlockState iblockstate = blockAccess.getBlockState(blockpos);
|
|
|
|
if (iblockstate.getBlock() != block) {
|
|
return false;
|
|
}
|
|
|
|
if (block == Blocks.stained_glass_pane && iblockstate.getValue(BlockStainedGlassPane.COLOR) != blockState
|
|
.getValue(BlockStainedGlassPane.COLOR)) {
|
|
return false;
|
|
}
|
|
|
|
iblockstate = iblockstate.getBlock().getActualState(iblockstate, blockAccess, blockpos);
|
|
double d0 = (double) quad.getMidX();
|
|
|
|
if (d0 < 0.4D) {
|
|
if (((Boolean) iblockstate.getValue(BlockPane.WEST)).booleanValue()) {
|
|
return true;
|
|
}
|
|
} else if (d0 > 0.6D) {
|
|
if (((Boolean) iblockstate.getValue(BlockPane.EAST)).booleanValue()) {
|
|
return true;
|
|
}
|
|
} else {
|
|
double d1 = quad.getMidZ();
|
|
|
|
if (d1 < 0.4D) {
|
|
if (((Boolean) iblockstate.getValue(BlockPane.NORTH)).booleanValue()) {
|
|
return true;
|
|
}
|
|
} else {
|
|
if (d1 <= 0.6D) {
|
|
return true;
|
|
}
|
|
|
|
if (((Boolean) iblockstate.getValue(BlockPane.SOUTH)).booleanValue()) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
protected static BakedQuad[] getQuads(EaglerTextureAtlasSprite sprite, BakedQuad quadIn, RenderEnv renderEnv) {
|
|
if (sprite == null) {
|
|
return null;
|
|
} else if (sprite == SPRITE_DEFAULT) {
|
|
return renderEnv.getArrayQuadsCtm(quadIn);
|
|
} else {
|
|
BakedQuad bakedquad = getQuad(sprite, quadIn);
|
|
BakedQuad[] abakedquad = renderEnv.getArrayQuadsCtm(bakedquad);
|
|
return abakedquad;
|
|
}
|
|
}
|
|
|
|
private static synchronized BakedQuad getQuad(EaglerTextureAtlasSprite sprite, BakedQuad quadIn) {
|
|
if (spriteQuadMaps == null) {
|
|
return quadIn;
|
|
} else {
|
|
int i = sprite.getIndexInMap();
|
|
|
|
if (i >= 0 && i < spriteQuadMaps.length) {
|
|
Map map = spriteQuadMaps[i];
|
|
|
|
if (map == null) {
|
|
map = new IdentityHashMap(1);
|
|
spriteQuadMaps[i] = map;
|
|
}
|
|
|
|
BakedQuad bakedquad = (BakedQuad) map.get(quadIn);
|
|
|
|
if (bakedquad == null) {
|
|
bakedquad = makeSpriteQuad(quadIn, sprite);
|
|
map.put(quadIn, bakedquad);
|
|
}
|
|
|
|
return bakedquad;
|
|
} else {
|
|
return quadIn;
|
|
}
|
|
}
|
|
}
|
|
|
|
private static synchronized BakedQuad getQuadFull(EaglerTextureAtlasSprite sprite, BakedQuad quadIn,
|
|
int tintIndex) {
|
|
if (spriteQuadFullMaps == null) {
|
|
return null;
|
|
} else if (sprite == null) {
|
|
return null;
|
|
} else {
|
|
int i = sprite.getIndexInMap();
|
|
|
|
if (i >= 0 && i < spriteQuadFullMaps.length) {
|
|
Map map = spriteQuadFullMaps[i];
|
|
|
|
if (map == null) {
|
|
map = new EnumMap(EnumFacing.class);
|
|
spriteQuadFullMaps[i] = map;
|
|
}
|
|
|
|
EnumFacing enumfacing = quadIn.getFace();
|
|
BakedQuad bakedquad = (BakedQuad) map.get(enumfacing);
|
|
|
|
if (bakedquad == null) {
|
|
bakedquad = BlockModelUtils.makeBakedQuad(enumfacing, sprite, tintIndex);
|
|
map.put(enumfacing, bakedquad);
|
|
}
|
|
|
|
return bakedquad;
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
|
|
private static BakedQuad makeSpriteQuad(BakedQuad quad, EaglerTextureAtlasSprite sprite) {
|
|
int[] aint = (int[]) quad.getVertexData().clone();
|
|
int[] aint2 = (int[]) quad.getVertexDataWithNormals().clone();
|
|
EaglerTextureAtlasSprite textureatlassprite = quad.getSprite();
|
|
|
|
for (int i = 0; i < 4; ++i) {
|
|
fixVertex(aint, aint2, i, textureatlassprite, sprite);
|
|
}
|
|
|
|
BakedQuad bakedquad = new BakedQuad(aint, aint2, quad.getTintIndex(), quad.getFace(), sprite);
|
|
return bakedquad;
|
|
}
|
|
|
|
private static void fixVertex(int[] data, int[] data2, int vertex, EaglerTextureAtlasSprite spriteFrom,
|
|
EaglerTextureAtlasSprite spriteTo) {
|
|
int i = data.length / 4;
|
|
int j = i * vertex;
|
|
int i2 = data2.length / 4;
|
|
int j2 = i2 * vertex;
|
|
float f = Float.intBitsToFloat(data[j + 4]);
|
|
float f1 = Float.intBitsToFloat(data[j + 4 + 1]);
|
|
double d0 = spriteFrom.getSpriteU16(f);
|
|
double d1 = spriteFrom.getSpriteV16(f1);
|
|
data[j + 4] = data2[j2 + 4] = Float.floatToRawIntBits(spriteTo.getInterpolatedU(d0));
|
|
data[j + 4 + 1] = data2[j2 + 4 + 1] = Float.floatToRawIntBits(spriteTo.getInterpolatedV(d1));
|
|
}
|
|
|
|
private static BakedQuad[] getConnectedTextureMultiPass(IBlockAccess blockAccess, IBlockState blockState,
|
|
BlockPos blockPos, EnumFacing side, BakedQuad quad, RenderEnv renderEnv) {
|
|
BakedQuad[] abakedquad = getConnectedTextureSingle(blockAccess, blockState, blockPos, side, quad, true, 0,
|
|
renderEnv);
|
|
|
|
if (!multipass) {
|
|
return abakedquad;
|
|
} else if (abakedquad.length == 1 && abakedquad[0] == quad) {
|
|
return abakedquad;
|
|
} else {
|
|
List<BakedQuad> list = renderEnv.getListQuadsCtmMultipass(abakedquad);
|
|
|
|
for (int i = 0; i < list.size(); ++i) {
|
|
BakedQuad bakedquad = (BakedQuad) list.get(i);
|
|
BakedQuad bakedquad1 = bakedquad;
|
|
|
|
for (int j = 0; j < 3; ++j) {
|
|
BakedQuad[] abakedquad1 = getConnectedTextureSingle(blockAccess, blockState, blockPos, side,
|
|
bakedquad1, false, j + 1, renderEnv);
|
|
|
|
if (abakedquad1.length != 1 || abakedquad1[0] == bakedquad1) {
|
|
break;
|
|
}
|
|
|
|
bakedquad1 = abakedquad1[0];
|
|
}
|
|
|
|
list.set(i, bakedquad1);
|
|
}
|
|
|
|
for (int k = 0; k < abakedquad.length; ++k) {
|
|
abakedquad[k] = (BakedQuad) list.get(k);
|
|
}
|
|
|
|
return abakedquad;
|
|
}
|
|
}
|
|
|
|
public static BakedQuad[] getConnectedTextureSingle(IBlockAccess blockAccess, IBlockState blockState,
|
|
BlockPos blockPos, EnumFacing facing, BakedQuad quad, boolean checkBlocks, int pass, RenderEnv renderEnv) {
|
|
Block block = blockState.getBlock();
|
|
|
|
if (!(blockState instanceof BlockStateBase)) {
|
|
return renderEnv.getArrayQuadsCtm(quad);
|
|
} else {
|
|
BlockStateBase blockstatebase = (BlockStateBase) blockState;
|
|
EaglerTextureAtlasSprite textureatlassprite = quad.getSprite();
|
|
|
|
if (tileProperties != null) {
|
|
int i = textureatlassprite.getIndexInMap();
|
|
|
|
if (i >= 0 && i < tileProperties.length) {
|
|
ConnectedProperties[] aconnectedproperties = tileProperties[i];
|
|
|
|
if (aconnectedproperties != null) {
|
|
int j = getSide(facing);
|
|
|
|
for (int k = 0; k < aconnectedproperties.length; ++k) {
|
|
ConnectedProperties connectedproperties = aconnectedproperties[k];
|
|
|
|
if (connectedproperties != null
|
|
&& connectedproperties.matchesBlockId(blockstatebase.getBlockId())) {
|
|
BakedQuad[] abakedquad = getConnectedTexture(connectedproperties, blockAccess,
|
|
blockstatebase, blockPos, j, quad, pass, renderEnv);
|
|
|
|
if (abakedquad != null) {
|
|
return abakedquad;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (blockProperties != null && checkBlocks) {
|
|
int l = renderEnv.getBlockId();
|
|
|
|
if (l >= 0 && l < blockProperties.length) {
|
|
ConnectedProperties[] aconnectedproperties1 = blockProperties[l];
|
|
|
|
if (aconnectedproperties1 != null) {
|
|
int i1 = getSide(facing);
|
|
|
|
for (int j1 = 0; j1 < aconnectedproperties1.length; ++j1) {
|
|
ConnectedProperties connectedproperties1 = aconnectedproperties1[j1];
|
|
|
|
if (connectedproperties1 != null && connectedproperties1.matchesIcon(textureatlassprite)) {
|
|
BakedQuad[] abakedquad1 = getConnectedTexture(connectedproperties1, blockAccess,
|
|
blockstatebase, blockPos, i1, quad, pass, renderEnv);
|
|
|
|
if (abakedquad1 != null) {
|
|
return abakedquad1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return renderEnv.getArrayQuadsCtm(quad);
|
|
}
|
|
}
|
|
|
|
public static int getSide(EnumFacing facing) {
|
|
if (facing == null) {
|
|
return -1;
|
|
} else {
|
|
switch (facing) {
|
|
case DOWN:
|
|
return 0;
|
|
|
|
case UP:
|
|
return 1;
|
|
|
|
case EAST:
|
|
return 5;
|
|
|
|
case WEST:
|
|
return 4;
|
|
|
|
case NORTH:
|
|
return 2;
|
|
|
|
case SOUTH:
|
|
return 3;
|
|
|
|
default:
|
|
return -1;
|
|
}
|
|
}
|
|
}
|
|
|
|
private static EnumFacing getFacing(int side) {
|
|
switch (side) {
|
|
case 0:
|
|
return EnumFacing.DOWN;
|
|
|
|
case 1:
|
|
return EnumFacing.UP;
|
|
|
|
case 2:
|
|
return EnumFacing.NORTH;
|
|
|
|
case 3:
|
|
return EnumFacing.SOUTH;
|
|
|
|
case 4:
|
|
return EnumFacing.WEST;
|
|
|
|
case 5:
|
|
return EnumFacing.EAST;
|
|
|
|
default:
|
|
return EnumFacing.UP;
|
|
}
|
|
}
|
|
|
|
private static BakedQuad[] getConnectedTexture(ConnectedProperties cp, IBlockAccess blockAccess,
|
|
BlockStateBase blockState, BlockPos blockPos, int side, BakedQuad quad, int pass, RenderEnv renderEnv) {
|
|
int i = 0;
|
|
int j = blockState.getMetadata();
|
|
int k = j;
|
|
Block block = blockState.getBlock();
|
|
|
|
if (block instanceof BlockRotatedPillar) {
|
|
i = getWoodAxis(side, j);
|
|
|
|
if (cp.getMetadataMax() <= 3) {
|
|
k = j & 3;
|
|
}
|
|
}
|
|
|
|
if (block instanceof BlockQuartz) {
|
|
i = getQuartzAxis(side, j);
|
|
|
|
if (cp.getMetadataMax() <= 2 && k > 2) {
|
|
k = 2;
|
|
}
|
|
}
|
|
|
|
if (!cp.matchesBlock(blockState.getBlockId(), k)) {
|
|
return null;
|
|
} else {
|
|
if (side >= 0 && cp.faces != 63) {
|
|
int l = side;
|
|
|
|
if (i != 0) {
|
|
l = fixSideByAxis(side, i);
|
|
}
|
|
|
|
if ((1 << l & cp.faces) == 0) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
int i1 = blockPos.getY();
|
|
|
|
if (cp.heights != null && !cp.heights.isInRange(i1)) {
|
|
return null;
|
|
} else {
|
|
if (cp.biomes != null) {
|
|
BiomeGenBase biomegenbase = blockAccess.getBiomeGenForCoords(blockPos);
|
|
|
|
if (!cp.matchesBiome(biomegenbase)) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
if (cp.nbtName != null) {
|
|
String s = TileEntityUtils.getTileEntityName(blockAccess, blockPos);
|
|
|
|
if (!cp.nbtName.matchesValue(s)) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
EaglerTextureAtlasSprite textureatlassprite = quad.getSprite();
|
|
|
|
switch (cp.method) {
|
|
case 1:
|
|
return getQuads(getConnectedTextureCtm(cp, blockAccess, blockState, blockPos, i, side,
|
|
textureatlassprite, j, renderEnv), quad, renderEnv);
|
|
|
|
case 2:
|
|
return getQuads(getConnectedTextureHorizontal(cp, blockAccess, blockState, blockPos, i, side,
|
|
textureatlassprite, j), quad, renderEnv);
|
|
|
|
case 3:
|
|
return getQuads(getConnectedTextureTop(cp, blockAccess, blockState, blockPos, i, side,
|
|
textureatlassprite, j), quad, renderEnv);
|
|
|
|
case 4:
|
|
return getQuads(getConnectedTextureRandom(cp, blockAccess, blockState, blockPos, side), quad,
|
|
renderEnv);
|
|
|
|
case 5:
|
|
return getQuads(getConnectedTextureRepeat(cp, blockPos, side), quad, renderEnv);
|
|
|
|
case 6:
|
|
return getQuads(getConnectedTextureVertical(cp, blockAccess, blockState, blockPos, i, side,
|
|
textureatlassprite, j), quad, renderEnv);
|
|
|
|
case 7:
|
|
return getQuads(getConnectedTextureFixed(cp), quad, renderEnv);
|
|
|
|
case 8:
|
|
return getQuads(getConnectedTextureHorizontalVertical(cp, blockAccess, blockState, blockPos, i,
|
|
side, textureatlassprite, j), quad, renderEnv);
|
|
|
|
case 9:
|
|
return getQuads(getConnectedTextureVerticalHorizontal(cp, blockAccess, blockState, blockPos, i,
|
|
side, textureatlassprite, j), quad, renderEnv);
|
|
|
|
case 10:
|
|
if (pass == 0) {
|
|
return getConnectedTextureCtmCompact(cp, blockAccess, blockState, blockPos, i, side, quad, j,
|
|
renderEnv);
|
|
}
|
|
|
|
default:
|
|
return null;
|
|
|
|
case 11:
|
|
return getConnectedTextureOverlay(cp, blockAccess, blockState, blockPos, i, side, quad, j,
|
|
renderEnv);
|
|
|
|
case 12:
|
|
return getConnectedTextureOverlayFixed(cp, quad, renderEnv);
|
|
|
|
case 13:
|
|
return getConnectedTextureOverlayRandom(cp, blockAccess, blockState, blockPos, side, quad,
|
|
renderEnv);
|
|
|
|
case 14:
|
|
return getConnectedTextureOverlayRepeat(cp, blockPos, side, quad, renderEnv);
|
|
|
|
case 15:
|
|
return getConnectedTextureOverlayCtm(cp, blockAccess, blockState, blockPos, i, side, quad, j,
|
|
renderEnv);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private static int fixSideByAxis(int side, int vertAxis) {
|
|
switch (vertAxis) {
|
|
case 0:
|
|
return side;
|
|
|
|
case 1:
|
|
switch (side) {
|
|
case 0:
|
|
return 2;
|
|
|
|
case 1:
|
|
return 3;
|
|
|
|
case 2:
|
|
return 1;
|
|
|
|
case 3:
|
|
return 0;
|
|
|
|
default:
|
|
return side;
|
|
}
|
|
|
|
case 2:
|
|
switch (side) {
|
|
case 0:
|
|
return 4;
|
|
|
|
case 1:
|
|
return 5;
|
|
|
|
case 2:
|
|
case 3:
|
|
default:
|
|
return side;
|
|
|
|
case 4:
|
|
return 1;
|
|
|
|
case 5:
|
|
return 0;
|
|
}
|
|
|
|
default:
|
|
return side;
|
|
}
|
|
}
|
|
|
|
private static int getWoodAxis(int side, int metadata) {
|
|
int i = (metadata & 12) >> 2;
|
|
|
|
switch (i) {
|
|
case 1:
|
|
return 2;
|
|
|
|
case 2:
|
|
return 1;
|
|
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
private static int getQuartzAxis(int side, int metadata) {
|
|
switch (metadata) {
|
|
case 3:
|
|
return 2;
|
|
|
|
case 4:
|
|
return 1;
|
|
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
private static EaglerTextureAtlasSprite getConnectedTextureRandom(ConnectedProperties cp, IBlockAccess blockAccess,
|
|
BlockStateBase blockState, BlockPos blockPos, int side) {
|
|
if (cp.tileIcons.length == 1) {
|
|
return cp.tileIcons[0];
|
|
} else {
|
|
int i = side / cp.symmetry * cp.symmetry;
|
|
|
|
if (cp.linked) {
|
|
BlockPos blockpos = blockPos.down();
|
|
|
|
for (IBlockState iblockstate = blockAccess.getBlockState(blockpos); iblockstate.getBlock() == blockState
|
|
.getBlock(); iblockstate = blockAccess.getBlockState(blockpos)) {
|
|
blockPos = blockpos;
|
|
blockpos = blockpos.down();
|
|
|
|
if (blockpos.getY() < 0) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
int l = Config.getRandom(blockPos, i) & Integer.MAX_VALUE;
|
|
|
|
for (int i1 = 0; i1 < cp.randomLoops; ++i1) {
|
|
l = Config.intHash(l);
|
|
}
|
|
|
|
int j1 = 0;
|
|
|
|
if (cp.weights == null) {
|
|
j1 = l % cp.tileIcons.length;
|
|
} else {
|
|
int j = l % cp.sumAllWeights;
|
|
int[] aint = cp.sumWeights;
|
|
|
|
for (int k = 0; k < aint.length; ++k) {
|
|
if (j < aint[k]) {
|
|
j1 = k;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return cp.tileIcons[j1];
|
|
}
|
|
}
|
|
|
|
private static EaglerTextureAtlasSprite getConnectedTextureFixed(ConnectedProperties cp) {
|
|
return cp.tileIcons[0];
|
|
}
|
|
|
|
private static EaglerTextureAtlasSprite getConnectedTextureRepeat(ConnectedProperties cp, BlockPos blockPos,
|
|
int side) {
|
|
if (cp.tileIcons.length == 1) {
|
|
return cp.tileIcons[0];
|
|
} else {
|
|
int i = blockPos.getX();
|
|
int j = blockPos.getY();
|
|
int k = blockPos.getZ();
|
|
int l = 0;
|
|
int i1 = 0;
|
|
|
|
switch (side) {
|
|
case 0:
|
|
l = i;
|
|
i1 = -k - 1;
|
|
break;
|
|
|
|
case 1:
|
|
l = i;
|
|
i1 = k;
|
|
break;
|
|
|
|
case 2:
|
|
l = -i - 1;
|
|
i1 = -j;
|
|
break;
|
|
|
|
case 3:
|
|
l = i;
|
|
i1 = -j;
|
|
break;
|
|
|
|
case 4:
|
|
l = k;
|
|
i1 = -j;
|
|
break;
|
|
|
|
case 5:
|
|
l = -k - 1;
|
|
i1 = -j;
|
|
}
|
|
|
|
l = l % cp.width;
|
|
i1 = i1 % cp.height;
|
|
|
|
if (l < 0) {
|
|
l += cp.width;
|
|
}
|
|
|
|
if (i1 < 0) {
|
|
i1 += cp.height;
|
|
}
|
|
|
|
int j1 = i1 * cp.width + l;
|
|
return cp.tileIcons[j1];
|
|
}
|
|
}
|
|
|
|
private static EaglerTextureAtlasSprite getConnectedTextureCtm(ConnectedProperties cp, IBlockAccess blockAccess,
|
|
IBlockState blockState, BlockPos blockPos, int vertAxis, int side, EaglerTextureAtlasSprite icon,
|
|
int metadata, RenderEnv renderEnv) {
|
|
int i = getConnectedTextureCtmIndex(cp, blockAccess, blockState, blockPos, vertAxis, side, icon, metadata,
|
|
renderEnv);
|
|
return cp.tileIcons[i];
|
|
}
|
|
|
|
private static synchronized BakedQuad[] getConnectedTextureCtmCompact(ConnectedProperties cp,
|
|
IBlockAccess blockAccess, IBlockState blockState, BlockPos blockPos, int vertAxis, int side, BakedQuad quad,
|
|
int metadata, RenderEnv renderEnv) {
|
|
EaglerTextureAtlasSprite textureatlassprite = quad.getSprite();
|
|
int i = getConnectedTextureCtmIndex(cp, blockAccess, blockState, blockPos, vertAxis, side, textureatlassprite,
|
|
metadata, renderEnv);
|
|
return ConnectedTexturesCompact.getConnectedTextureCtmCompact(i, cp, side, quad, renderEnv);
|
|
}
|
|
|
|
private static BakedQuad[] getConnectedTextureOverlay(ConnectedProperties cp, IBlockAccess blockAccess,
|
|
IBlockState blockState, BlockPos blockPos, int vertAxis, int side, BakedQuad quad, int metadata,
|
|
RenderEnv renderEnv) {
|
|
if (!quad.isFullQuad()) {
|
|
return null;
|
|
} else {
|
|
EaglerTextureAtlasSprite textureatlassprite = quad.getSprite();
|
|
BlockDir[] ablockdir = getSideDirections(side, vertAxis);
|
|
boolean[] aboolean = renderEnv.getBorderFlags();
|
|
|
|
for (int i = 0; i < 4; ++i) {
|
|
aboolean[i] = isNeighbourOverlay(cp, blockAccess, blockState, ablockdir[i].offset(blockPos), side,
|
|
textureatlassprite, metadata);
|
|
}
|
|
|
|
ListQuadsOverlay listquadsoverlay = renderEnv.getListQuadsOverlay(cp.layer);
|
|
Object dirEdges;
|
|
|
|
try {
|
|
if (!aboolean[0] || !aboolean[1] || !aboolean[2] || !aboolean[3]) {
|
|
if (aboolean[0] && aboolean[1] && aboolean[2]) {
|
|
listquadsoverlay.addQuad(getQuadFull(cp.tileIcons[5], quad, cp.tintIndex), cp.tintBlockState);
|
|
dirEdges = null;
|
|
return (BakedQuad[]) dirEdges;
|
|
}
|
|
|
|
if (aboolean[0] && aboolean[2] && aboolean[3]) {
|
|
listquadsoverlay.addQuad(getQuadFull(cp.tileIcons[6], quad, cp.tintIndex), cp.tintBlockState);
|
|
dirEdges = null;
|
|
return (BakedQuad[]) dirEdges;
|
|
}
|
|
|
|
if (aboolean[1] && aboolean[2] && aboolean[3]) {
|
|
listquadsoverlay.addQuad(getQuadFull(cp.tileIcons[12], quad, cp.tintIndex), cp.tintBlockState);
|
|
dirEdges = null;
|
|
return (BakedQuad[]) dirEdges;
|
|
}
|
|
|
|
if (aboolean[0] && aboolean[1] && aboolean[3]) {
|
|
listquadsoverlay.addQuad(getQuadFull(cp.tileIcons[13], quad, cp.tintIndex), cp.tintBlockState);
|
|
dirEdges = null;
|
|
return (BakedQuad[]) dirEdges;
|
|
}
|
|
|
|
BlockDir[] ablockdir1 = getEdgeDirections(side, vertAxis);
|
|
boolean[] aboolean1 = renderEnv.getBorderFlags2();
|
|
|
|
for (int j = 0; j < 4; ++j) {
|
|
aboolean1[j] = isNeighbourOverlay(cp, blockAccess, blockState, ablockdir1[j].offset(blockPos),
|
|
side, textureatlassprite, metadata);
|
|
}
|
|
|
|
if (aboolean[1] && aboolean[2]) {
|
|
listquadsoverlay.addQuad(getQuadFull(cp.tileIcons[3], quad, cp.tintIndex), cp.tintBlockState);
|
|
|
|
if (aboolean1[3]) {
|
|
listquadsoverlay.addQuad(getQuadFull(cp.tileIcons[16], quad, cp.tintIndex),
|
|
cp.tintBlockState);
|
|
}
|
|
|
|
Object object4 = null;
|
|
return (BakedQuad[]) object4;
|
|
}
|
|
|
|
if (aboolean[0] && aboolean[2]) {
|
|
listquadsoverlay.addQuad(getQuadFull(cp.tileIcons[4], quad, cp.tintIndex), cp.tintBlockState);
|
|
|
|
if (aboolean1[2]) {
|
|
listquadsoverlay.addQuad(getQuadFull(cp.tileIcons[14], quad, cp.tintIndex),
|
|
cp.tintBlockState);
|
|
}
|
|
|
|
Object object3 = null;
|
|
return (BakedQuad[]) object3;
|
|
}
|
|
|
|
if (aboolean[1] && aboolean[3]) {
|
|
listquadsoverlay.addQuad(getQuadFull(cp.tileIcons[10], quad, cp.tintIndex), cp.tintBlockState);
|
|
|
|
if (aboolean1[1]) {
|
|
listquadsoverlay.addQuad(getQuadFull(cp.tileIcons[2], quad, cp.tintIndex),
|
|
cp.tintBlockState);
|
|
}
|
|
|
|
Object object2 = null;
|
|
return (BakedQuad[]) object2;
|
|
}
|
|
|
|
if (aboolean[0] && aboolean[3]) {
|
|
listquadsoverlay.addQuad(getQuadFull(cp.tileIcons[11], quad, cp.tintIndex), cp.tintBlockState);
|
|
|
|
if (aboolean1[0]) {
|
|
listquadsoverlay.addQuad(getQuadFull(cp.tileIcons[0], quad, cp.tintIndex),
|
|
cp.tintBlockState);
|
|
}
|
|
|
|
Object object1 = null;
|
|
return (BakedQuad[]) object1;
|
|
}
|
|
|
|
boolean[] aboolean2 = renderEnv.getBorderFlags3();
|
|
|
|
for (int k = 0; k < 4; ++k) {
|
|
aboolean2[k] = isNeighbourMatching(cp, blockAccess, blockState, ablockdir[k].offset(blockPos),
|
|
side, textureatlassprite, metadata);
|
|
}
|
|
|
|
if (aboolean[0]) {
|
|
listquadsoverlay.addQuad(getQuadFull(cp.tileIcons[9], quad, cp.tintIndex), cp.tintBlockState);
|
|
}
|
|
|
|
if (aboolean[1]) {
|
|
listquadsoverlay.addQuad(getQuadFull(cp.tileIcons[7], quad, cp.tintIndex), cp.tintBlockState);
|
|
}
|
|
|
|
if (aboolean[2]) {
|
|
listquadsoverlay.addQuad(getQuadFull(cp.tileIcons[1], quad, cp.tintIndex), cp.tintBlockState);
|
|
}
|
|
|
|
if (aboolean[3]) {
|
|
listquadsoverlay.addQuad(getQuadFull(cp.tileIcons[15], quad, cp.tintIndex), cp.tintBlockState);
|
|
}
|
|
|
|
if (aboolean1[0] && (aboolean2[1] || aboolean2[2]) && !aboolean[1] && !aboolean[2]) {
|
|
listquadsoverlay.addQuad(getQuadFull(cp.tileIcons[0], quad, cp.tintIndex), cp.tintBlockState);
|
|
}
|
|
|
|
if (aboolean1[1] && (aboolean2[0] || aboolean2[2]) && !aboolean[0] && !aboolean[2]) {
|
|
listquadsoverlay.addQuad(getQuadFull(cp.tileIcons[2], quad, cp.tintIndex), cp.tintBlockState);
|
|
}
|
|
|
|
if (aboolean1[2] && (aboolean2[1] || aboolean2[3]) && !aboolean[1] && !aboolean[3]) {
|
|
listquadsoverlay.addQuad(getQuadFull(cp.tileIcons[14], quad, cp.tintIndex), cp.tintBlockState);
|
|
}
|
|
|
|
if (aboolean1[3] && (aboolean2[0] || aboolean2[3]) && !aboolean[0] && !aboolean[3]) {
|
|
listquadsoverlay.addQuad(getQuadFull(cp.tileIcons[16], quad, cp.tintIndex), cp.tintBlockState);
|
|
}
|
|
|
|
Object object5 = null;
|
|
return (BakedQuad[]) object5;
|
|
}
|
|
|
|
listquadsoverlay.addQuad(getQuadFull(cp.tileIcons[8], quad, cp.tintIndex), cp.tintBlockState);
|
|
dirEdges = null;
|
|
} finally {
|
|
if (listquadsoverlay.size() > 0) {
|
|
renderEnv.setOverlaysRendered(true);
|
|
}
|
|
}
|
|
|
|
return (BakedQuad[]) dirEdges;
|
|
}
|
|
}
|
|
|
|
private static BakedQuad[] getConnectedTextureOverlayFixed(ConnectedProperties cp, BakedQuad quad,
|
|
RenderEnv renderEnv) {
|
|
if (!quad.isFullQuad()) {
|
|
return null;
|
|
} else {
|
|
ListQuadsOverlay listquadsoverlay = renderEnv.getListQuadsOverlay(cp.layer);
|
|
Object object;
|
|
|
|
try {
|
|
EaglerTextureAtlasSprite textureatlassprite = getConnectedTextureFixed(cp);
|
|
|
|
if (textureatlassprite != null) {
|
|
listquadsoverlay.addQuad(getQuadFull(textureatlassprite, quad, cp.tintIndex), cp.tintBlockState);
|
|
}
|
|
|
|
object = null;
|
|
} finally {
|
|
if (listquadsoverlay.size() > 0) {
|
|
renderEnv.setOverlaysRendered(true);
|
|
}
|
|
}
|
|
|
|
return (BakedQuad[]) object;
|
|
}
|
|
}
|
|
|
|
private static BakedQuad[] getConnectedTextureOverlayRandom(ConnectedProperties cp, IBlockAccess blockAccess,
|
|
BlockStateBase blockState, BlockPos blockPos, int side, BakedQuad quad, RenderEnv renderEnv) {
|
|
if (!quad.isFullQuad()) {
|
|
return null;
|
|
} else {
|
|
ListQuadsOverlay listquadsoverlay = renderEnv.getListQuadsOverlay(cp.layer);
|
|
Object object;
|
|
|
|
try {
|
|
EaglerTextureAtlasSprite textureatlassprite = getConnectedTextureRandom(cp, blockAccess, blockState,
|
|
blockPos, side);
|
|
|
|
if (textureatlassprite != null) {
|
|
listquadsoverlay.addQuad(getQuadFull(textureatlassprite, quad, cp.tintIndex), cp.tintBlockState);
|
|
}
|
|
|
|
object = null;
|
|
} finally {
|
|
if (listquadsoverlay.size() > 0) {
|
|
renderEnv.setOverlaysRendered(true);
|
|
}
|
|
}
|
|
|
|
return (BakedQuad[]) object;
|
|
}
|
|
}
|
|
|
|
private static BakedQuad[] getConnectedTextureOverlayRepeat(ConnectedProperties cp, BlockPos blockPos, int side,
|
|
BakedQuad quad, RenderEnv renderEnv) {
|
|
if (!quad.isFullQuad()) {
|
|
return null;
|
|
} else {
|
|
ListQuadsOverlay listquadsoverlay = renderEnv.getListQuadsOverlay(cp.layer);
|
|
Object object;
|
|
|
|
try {
|
|
EaglerTextureAtlasSprite textureatlassprite = getConnectedTextureRepeat(cp, blockPos, side);
|
|
|
|
if (textureatlassprite != null) {
|
|
listquadsoverlay.addQuad(getQuadFull(textureatlassprite, quad, cp.tintIndex), cp.tintBlockState);
|
|
}
|
|
|
|
object = null;
|
|
} finally {
|
|
if (listquadsoverlay.size() > 0) {
|
|
renderEnv.setOverlaysRendered(true);
|
|
}
|
|
}
|
|
|
|
return (BakedQuad[]) object;
|
|
}
|
|
}
|
|
|
|
private static BakedQuad[] getConnectedTextureOverlayCtm(ConnectedProperties cp, IBlockAccess blockAccess,
|
|
IBlockState blockState, BlockPos blockPos, int vertAxis, int side, BakedQuad quad, int metadata,
|
|
RenderEnv renderEnv) {
|
|
if (!quad.isFullQuad()) {
|
|
return null;
|
|
} else {
|
|
ListQuadsOverlay listquadsoverlay = renderEnv.getListQuadsOverlay(cp.layer);
|
|
Object object;
|
|
|
|
try {
|
|
EaglerTextureAtlasSprite textureatlassprite = getConnectedTextureCtm(cp, blockAccess, blockState,
|
|
blockPos, vertAxis, side, quad.getSprite(), metadata, renderEnv);
|
|
|
|
if (textureatlassprite != null) {
|
|
listquadsoverlay.addQuad(getQuadFull(textureatlassprite, quad, cp.tintIndex), cp.tintBlockState);
|
|
}
|
|
|
|
object = null;
|
|
} finally {
|
|
if (listquadsoverlay.size() > 0) {
|
|
renderEnv.setOverlaysRendered(true);
|
|
}
|
|
}
|
|
|
|
return (BakedQuad[]) object;
|
|
}
|
|
}
|
|
|
|
private static BlockDir[] getSideDirections(int side, int vertAxis) {
|
|
switch (side) {
|
|
case 0:
|
|
return SIDES_Y_NEG_DOWN;
|
|
|
|
case 1:
|
|
return SIDES_Y_POS_UP;
|
|
|
|
case 2:
|
|
if (vertAxis == 1) {
|
|
return SIDES_Z_NEG_NORTH_Z_AXIS;
|
|
}
|
|
|
|
return SIDES_Z_NEG_NORTH;
|
|
|
|
case 3:
|
|
return SIDES_Z_POS_SOUTH;
|
|
|
|
case 4:
|
|
return SIDES_X_NEG_WEST;
|
|
|
|
case 5:
|
|
if (vertAxis == 2) {
|
|
return SIDES_X_POS_EAST_X_AXIS;
|
|
}
|
|
|
|
return SIDES_X_POS_EAST;
|
|
|
|
default:
|
|
throw new IllegalArgumentException("Unknown side: " + side);
|
|
}
|
|
}
|
|
|
|
private static BlockDir[] getEdgeDirections(int side, int vertAxis) {
|
|
switch (side) {
|
|
case 0:
|
|
return EDGES_Y_NEG_DOWN;
|
|
|
|
case 1:
|
|
return EDGES_Y_POS_UP;
|
|
|
|
case 2:
|
|
if (vertAxis == 1) {
|
|
return EDGES_Z_NEG_NORTH_Z_AXIS;
|
|
}
|
|
|
|
return EDGES_Z_NEG_NORTH;
|
|
|
|
case 3:
|
|
return EDGES_Z_POS_SOUTH;
|
|
|
|
case 4:
|
|
return EDGES_X_NEG_WEST;
|
|
|
|
case 5:
|
|
if (vertAxis == 2) {
|
|
return EDGES_X_POS_EAST_X_AXIS;
|
|
}
|
|
|
|
return EDGES_X_POS_EAST;
|
|
|
|
default:
|
|
throw new IllegalArgumentException("Unknown side: " + side);
|
|
}
|
|
}
|
|
|
|
protected static Map[][] getSpriteQuadCompactMaps() {
|
|
return spriteQuadCompactMaps;
|
|
}
|
|
|
|
private static int getConnectedTextureCtmIndex(ConnectedProperties cp, IBlockAccess blockAccess,
|
|
IBlockState blockState, BlockPos blockPos, int vertAxis, int side, EaglerTextureAtlasSprite icon,
|
|
int metadata, RenderEnv renderEnv) {
|
|
boolean[] aboolean = renderEnv.getBorderFlags();
|
|
|
|
switch (side) {
|
|
case 0:
|
|
aboolean[0] = isNeighbour(cp, blockAccess, blockState, blockPos.west(), side, icon, metadata);
|
|
aboolean[1] = isNeighbour(cp, blockAccess, blockState, blockPos.east(), side, icon, metadata);
|
|
aboolean[2] = isNeighbour(cp, blockAccess, blockState, blockPos.north(), side, icon, metadata);
|
|
aboolean[3] = isNeighbour(cp, blockAccess, blockState, blockPos.south(), side, icon, metadata);
|
|
|
|
if (cp.innerSeams) {
|
|
BlockPos blockpos6 = blockPos.down();
|
|
aboolean[0] = aboolean[0]
|
|
&& !isNeighbour(cp, blockAccess, blockState, blockpos6.west(), side, icon, metadata);
|
|
aboolean[1] = aboolean[1]
|
|
&& !isNeighbour(cp, blockAccess, blockState, blockpos6.east(), side, icon, metadata);
|
|
aboolean[2] = aboolean[2]
|
|
&& !isNeighbour(cp, blockAccess, blockState, blockpos6.north(), side, icon, metadata);
|
|
aboolean[3] = aboolean[3]
|
|
&& !isNeighbour(cp, blockAccess, blockState, blockpos6.south(), side, icon, metadata);
|
|
}
|
|
|
|
break;
|
|
|
|
case 1:
|
|
aboolean[0] = isNeighbour(cp, blockAccess, blockState, blockPos.west(), side, icon, metadata);
|
|
aboolean[1] = isNeighbour(cp, blockAccess, blockState, blockPos.east(), side, icon, metadata);
|
|
aboolean[2] = isNeighbour(cp, blockAccess, blockState, blockPos.south(), side, icon, metadata);
|
|
aboolean[3] = isNeighbour(cp, blockAccess, blockState, blockPos.north(), side, icon, metadata);
|
|
|
|
if (cp.innerSeams) {
|
|
BlockPos blockpos5 = blockPos.up();
|
|
aboolean[0] = aboolean[0]
|
|
&& !isNeighbour(cp, blockAccess, blockState, blockpos5.west(), side, icon, metadata);
|
|
aboolean[1] = aboolean[1]
|
|
&& !isNeighbour(cp, blockAccess, blockState, blockpos5.east(), side, icon, metadata);
|
|
aboolean[2] = aboolean[2]
|
|
&& !isNeighbour(cp, blockAccess, blockState, blockpos5.south(), side, icon, metadata);
|
|
aboolean[3] = aboolean[3]
|
|
&& !isNeighbour(cp, blockAccess, blockState, blockpos5.north(), side, icon, metadata);
|
|
}
|
|
|
|
break;
|
|
|
|
case 2:
|
|
aboolean[0] = isNeighbour(cp, blockAccess, blockState, blockPos.east(), side, icon, metadata);
|
|
aboolean[1] = isNeighbour(cp, blockAccess, blockState, blockPos.west(), side, icon, metadata);
|
|
aboolean[2] = isNeighbour(cp, blockAccess, blockState, blockPos.down(), side, icon, metadata);
|
|
aboolean[3] = isNeighbour(cp, blockAccess, blockState, blockPos.up(), side, icon, metadata);
|
|
|
|
if (cp.innerSeams) {
|
|
BlockPos blockpos4 = blockPos.north();
|
|
aboolean[0] = aboolean[0]
|
|
&& !isNeighbour(cp, blockAccess, blockState, blockpos4.east(), side, icon, metadata);
|
|
aboolean[1] = aboolean[1]
|
|
&& !isNeighbour(cp, blockAccess, blockState, blockpos4.west(), side, icon, metadata);
|
|
aboolean[2] = aboolean[2]
|
|
&& !isNeighbour(cp, blockAccess, blockState, blockpos4.down(), side, icon, metadata);
|
|
aboolean[3] = aboolean[3]
|
|
&& !isNeighbour(cp, blockAccess, blockState, blockpos4.up(), side, icon, metadata);
|
|
}
|
|
|
|
if (vertAxis == 1) {
|
|
switchValues(0, 1, aboolean);
|
|
switchValues(2, 3, aboolean);
|
|
}
|
|
|
|
break;
|
|
|
|
case 3:
|
|
aboolean[0] = isNeighbour(cp, blockAccess, blockState, blockPos.west(), side, icon, metadata);
|
|
aboolean[1] = isNeighbour(cp, blockAccess, blockState, blockPos.east(), side, icon, metadata);
|
|
aboolean[2] = isNeighbour(cp, blockAccess, blockState, blockPos.down(), side, icon, metadata);
|
|
aboolean[3] = isNeighbour(cp, blockAccess, blockState, blockPos.up(), side, icon, metadata);
|
|
|
|
if (cp.innerSeams) {
|
|
BlockPos blockpos3 = blockPos.south();
|
|
aboolean[0] = aboolean[0]
|
|
&& !isNeighbour(cp, blockAccess, blockState, blockpos3.west(), side, icon, metadata);
|
|
aboolean[1] = aboolean[1]
|
|
&& !isNeighbour(cp, blockAccess, blockState, blockpos3.east(), side, icon, metadata);
|
|
aboolean[2] = aboolean[2]
|
|
&& !isNeighbour(cp, blockAccess, blockState, blockpos3.down(), side, icon, metadata);
|
|
aboolean[3] = aboolean[3]
|
|
&& !isNeighbour(cp, blockAccess, blockState, blockpos3.up(), side, icon, metadata);
|
|
}
|
|
|
|
break;
|
|
|
|
case 4:
|
|
aboolean[0] = isNeighbour(cp, blockAccess, blockState, blockPos.north(), side, icon, metadata);
|
|
aboolean[1] = isNeighbour(cp, blockAccess, blockState, blockPos.south(), side, icon, metadata);
|
|
aboolean[2] = isNeighbour(cp, blockAccess, blockState, blockPos.down(), side, icon, metadata);
|
|
aboolean[3] = isNeighbour(cp, blockAccess, blockState, blockPos.up(), side, icon, metadata);
|
|
|
|
if (cp.innerSeams) {
|
|
BlockPos blockpos2 = blockPos.west();
|
|
aboolean[0] = aboolean[0]
|
|
&& !isNeighbour(cp, blockAccess, blockState, blockpos2.north(), side, icon, metadata);
|
|
aboolean[1] = aboolean[1]
|
|
&& !isNeighbour(cp, blockAccess, blockState, blockpos2.south(), side, icon, metadata);
|
|
aboolean[2] = aboolean[2]
|
|
&& !isNeighbour(cp, blockAccess, blockState, blockpos2.down(), side, icon, metadata);
|
|
aboolean[3] = aboolean[3]
|
|
&& !isNeighbour(cp, blockAccess, blockState, blockpos2.up(), side, icon, metadata);
|
|
}
|
|
|
|
break;
|
|
|
|
case 5:
|
|
aboolean[0] = isNeighbour(cp, blockAccess, blockState, blockPos.south(), side, icon, metadata);
|
|
aboolean[1] = isNeighbour(cp, blockAccess, blockState, blockPos.north(), side, icon, metadata);
|
|
aboolean[2] = isNeighbour(cp, blockAccess, blockState, blockPos.down(), side, icon, metadata);
|
|
aboolean[3] = isNeighbour(cp, blockAccess, blockState, blockPos.up(), side, icon, metadata);
|
|
|
|
if (cp.innerSeams) {
|
|
BlockPos blockpos = blockPos.east();
|
|
aboolean[0] = aboolean[0]
|
|
&& !isNeighbour(cp, blockAccess, blockState, blockpos.south(), side, icon, metadata);
|
|
aboolean[1] = aboolean[1]
|
|
&& !isNeighbour(cp, blockAccess, blockState, blockpos.north(), side, icon, metadata);
|
|
aboolean[2] = aboolean[2]
|
|
&& !isNeighbour(cp, blockAccess, blockState, blockpos.down(), side, icon, metadata);
|
|
aboolean[3] = aboolean[3]
|
|
&& !isNeighbour(cp, blockAccess, blockState, blockpos.up(), side, icon, metadata);
|
|
}
|
|
|
|
if (vertAxis == 2) {
|
|
switchValues(0, 1, aboolean);
|
|
switchValues(2, 3, aboolean);
|
|
}
|
|
}
|
|
|
|
int i = 0;
|
|
|
|
if (aboolean[0] & !aboolean[1] & !aboolean[2] & !aboolean[3]) {
|
|
i = 3;
|
|
} else if (!aboolean[0] & aboolean[1] & !aboolean[2] & !aboolean[3]) {
|
|
i = 1;
|
|
} else if (!aboolean[0] & !aboolean[1] & aboolean[2] & !aboolean[3]) {
|
|
i = 12;
|
|
} else if (!aboolean[0] & !aboolean[1] & !aboolean[2] & aboolean[3]) {
|
|
i = 36;
|
|
} else if (aboolean[0] & aboolean[1] & !aboolean[2] & !aboolean[3]) {
|
|
i = 2;
|
|
} else if (!aboolean[0] & !aboolean[1] & aboolean[2] & aboolean[3]) {
|
|
i = 24;
|
|
} else if (aboolean[0] & !aboolean[1] & aboolean[2] & !aboolean[3]) {
|
|
i = 15;
|
|
} else if (aboolean[0] & !aboolean[1] & !aboolean[2] & aboolean[3]) {
|
|
i = 39;
|
|
} else if (!aboolean[0] & aboolean[1] & aboolean[2] & !aboolean[3]) {
|
|
i = 13;
|
|
} else if (!aboolean[0] & aboolean[1] & !aboolean[2] & aboolean[3]) {
|
|
i = 37;
|
|
} else if (!aboolean[0] & aboolean[1] & aboolean[2] & aboolean[3]) {
|
|
i = 25;
|
|
} else if (aboolean[0] & !aboolean[1] & aboolean[2] & aboolean[3]) {
|
|
i = 27;
|
|
} else if (aboolean[0] & aboolean[1] & !aboolean[2] & aboolean[3]) {
|
|
i = 38;
|
|
} else if (aboolean[0] & aboolean[1] & aboolean[2] & !aboolean[3]) {
|
|
i = 14;
|
|
} else if (aboolean[0] & aboolean[1] & aboolean[2] & aboolean[3]) {
|
|
i = 26;
|
|
}
|
|
|
|
if (i == 0) {
|
|
return i;
|
|
} else if (!Config.isConnectedTexturesFancy()) {
|
|
return i;
|
|
} else {
|
|
switch (side) {
|
|
case 0:
|
|
aboolean[0] = !isNeighbour(cp, blockAccess, blockState, blockPos.east().north(), side, icon, metadata);
|
|
aboolean[1] = !isNeighbour(cp, blockAccess, blockState, blockPos.west().north(), side, icon, metadata);
|
|
aboolean[2] = !isNeighbour(cp, blockAccess, blockState, blockPos.east().south(), side, icon, metadata);
|
|
aboolean[3] = !isNeighbour(cp, blockAccess, blockState, blockPos.west().south(), side, icon, metadata);
|
|
|
|
if (cp.innerSeams) {
|
|
BlockPos blockpos11 = blockPos.down();
|
|
aboolean[0] = aboolean[0] || isNeighbour(cp, blockAccess, blockState, blockpos11.east().north(),
|
|
side, icon, metadata);
|
|
aboolean[1] = aboolean[1] || isNeighbour(cp, blockAccess, blockState, blockpos11.west().north(),
|
|
side, icon, metadata);
|
|
aboolean[2] = aboolean[2] || isNeighbour(cp, blockAccess, blockState, blockpos11.east().south(),
|
|
side, icon, metadata);
|
|
aboolean[3] = aboolean[3] || isNeighbour(cp, blockAccess, blockState, blockpos11.west().south(),
|
|
side, icon, metadata);
|
|
}
|
|
|
|
break;
|
|
|
|
case 1:
|
|
aboolean[0] = !isNeighbour(cp, blockAccess, blockState, blockPos.east().south(), side, icon, metadata);
|
|
aboolean[1] = !isNeighbour(cp, blockAccess, blockState, blockPos.west().south(), side, icon, metadata);
|
|
aboolean[2] = !isNeighbour(cp, blockAccess, blockState, blockPos.east().north(), side, icon, metadata);
|
|
aboolean[3] = !isNeighbour(cp, blockAccess, blockState, blockPos.west().north(), side, icon, metadata);
|
|
|
|
if (cp.innerSeams) {
|
|
BlockPos blockpos10 = blockPos.up();
|
|
aboolean[0] = aboolean[0] || isNeighbour(cp, blockAccess, blockState, blockpos10.east().south(),
|
|
side, icon, metadata);
|
|
aboolean[1] = aboolean[1] || isNeighbour(cp, blockAccess, blockState, blockpos10.west().south(),
|
|
side, icon, metadata);
|
|
aboolean[2] = aboolean[2] || isNeighbour(cp, blockAccess, blockState, blockpos10.east().north(),
|
|
side, icon, metadata);
|
|
aboolean[3] = aboolean[3] || isNeighbour(cp, blockAccess, blockState, blockpos10.west().north(),
|
|
side, icon, metadata);
|
|
}
|
|
|
|
break;
|
|
|
|
case 2:
|
|
aboolean[0] = !isNeighbour(cp, blockAccess, blockState, blockPos.west().down(), side, icon, metadata);
|
|
aboolean[1] = !isNeighbour(cp, blockAccess, blockState, blockPos.east().down(), side, icon, metadata);
|
|
aboolean[2] = !isNeighbour(cp, blockAccess, blockState, blockPos.west().up(), side, icon, metadata);
|
|
aboolean[3] = !isNeighbour(cp, blockAccess, blockState, blockPos.east().up(), side, icon, metadata);
|
|
|
|
if (cp.innerSeams) {
|
|
BlockPos blockpos9 = blockPos.north();
|
|
aboolean[0] = aboolean[0]
|
|
|| isNeighbour(cp, blockAccess, blockState, blockpos9.west().down(), side, icon, metadata);
|
|
aboolean[1] = aboolean[1]
|
|
|| isNeighbour(cp, blockAccess, blockState, blockpos9.east().down(), side, icon, metadata);
|
|
aboolean[2] = aboolean[2]
|
|
|| isNeighbour(cp, blockAccess, blockState, blockpos9.west().up(), side, icon, metadata);
|
|
aboolean[3] = aboolean[3]
|
|
|| isNeighbour(cp, blockAccess, blockState, blockpos9.east().up(), side, icon, metadata);
|
|
}
|
|
|
|
if (vertAxis == 1) {
|
|
switchValues(0, 3, aboolean);
|
|
switchValues(1, 2, aboolean);
|
|
}
|
|
|
|
break;
|
|
|
|
case 3:
|
|
aboolean[0] = !isNeighbour(cp, blockAccess, blockState, blockPos.east().down(), side, icon, metadata);
|
|
aboolean[1] = !isNeighbour(cp, blockAccess, blockState, blockPos.west().down(), side, icon, metadata);
|
|
aboolean[2] = !isNeighbour(cp, blockAccess, blockState, blockPos.east().up(), side, icon, metadata);
|
|
aboolean[3] = !isNeighbour(cp, blockAccess, blockState, blockPos.west().up(), side, icon, metadata);
|
|
|
|
if (cp.innerSeams) {
|
|
BlockPos blockpos8 = blockPos.south();
|
|
aboolean[0] = aboolean[0]
|
|
|| isNeighbour(cp, blockAccess, blockState, blockpos8.east().down(), side, icon, metadata);
|
|
aboolean[1] = aboolean[1]
|
|
|| isNeighbour(cp, blockAccess, blockState, blockpos8.west().down(), side, icon, metadata);
|
|
aboolean[2] = aboolean[2]
|
|
|| isNeighbour(cp, blockAccess, blockState, blockpos8.east().up(), side, icon, metadata);
|
|
aboolean[3] = aboolean[3]
|
|
|| isNeighbour(cp, blockAccess, blockState, blockpos8.west().up(), side, icon, metadata);
|
|
}
|
|
|
|
break;
|
|
|
|
case 4:
|
|
aboolean[0] = !isNeighbour(cp, blockAccess, blockState, blockPos.down().south(), side, icon, metadata);
|
|
aboolean[1] = !isNeighbour(cp, blockAccess, blockState, blockPos.down().north(), side, icon, metadata);
|
|
aboolean[2] = !isNeighbour(cp, blockAccess, blockState, blockPos.up().south(), side, icon, metadata);
|
|
aboolean[3] = !isNeighbour(cp, blockAccess, blockState, blockPos.up().north(), side, icon, metadata);
|
|
|
|
if (cp.innerSeams) {
|
|
BlockPos blockpos7 = blockPos.west();
|
|
aboolean[0] = aboolean[0]
|
|
|| isNeighbour(cp, blockAccess, blockState, blockpos7.down().south(), side, icon, metadata);
|
|
aboolean[1] = aboolean[1]
|
|
|| isNeighbour(cp, blockAccess, blockState, blockpos7.down().north(), side, icon, metadata);
|
|
aboolean[2] = aboolean[2]
|
|
|| isNeighbour(cp, blockAccess, blockState, blockpos7.up().south(), side, icon, metadata);
|
|
aboolean[3] = aboolean[3]
|
|
|| isNeighbour(cp, blockAccess, blockState, blockpos7.up().north(), side, icon, metadata);
|
|
}
|
|
|
|
break;
|
|
|
|
case 5:
|
|
aboolean[0] = !isNeighbour(cp, blockAccess, blockState, blockPos.down().north(), side, icon, metadata);
|
|
aboolean[1] = !isNeighbour(cp, blockAccess, blockState, blockPos.down().south(), side, icon, metadata);
|
|
aboolean[2] = !isNeighbour(cp, blockAccess, blockState, blockPos.up().north(), side, icon, metadata);
|
|
aboolean[3] = !isNeighbour(cp, blockAccess, blockState, blockPos.up().south(), side, icon, metadata);
|
|
|
|
if (cp.innerSeams) {
|
|
BlockPos blockpos1 = blockPos.east();
|
|
aboolean[0] = aboolean[0]
|
|
|| isNeighbour(cp, blockAccess, blockState, blockpos1.down().north(), side, icon, metadata);
|
|
aboolean[1] = aboolean[1]
|
|
|| isNeighbour(cp, blockAccess, blockState, blockpos1.down().south(), side, icon, metadata);
|
|
aboolean[2] = aboolean[2]
|
|
|| isNeighbour(cp, blockAccess, blockState, blockpos1.up().north(), side, icon, metadata);
|
|
aboolean[3] = aboolean[3]
|
|
|| isNeighbour(cp, blockAccess, blockState, blockpos1.up().south(), side, icon, metadata);
|
|
}
|
|
|
|
if (vertAxis == 2) {
|
|
switchValues(0, 3, aboolean);
|
|
switchValues(1, 2, aboolean);
|
|
}
|
|
}
|
|
|
|
if (i == 13 && aboolean[0]) {
|
|
i = 4;
|
|
} else if (i == 15 && aboolean[1]) {
|
|
i = 5;
|
|
} else if (i == 37 && aboolean[2]) {
|
|
i = 16;
|
|
} else if (i == 39 && aboolean[3]) {
|
|
i = 17;
|
|
} else if (i == 14 && aboolean[0] && aboolean[1]) {
|
|
i = 7;
|
|
} else if (i == 25 && aboolean[0] && aboolean[2]) {
|
|
i = 6;
|
|
} else if (i == 27 && aboolean[3] && aboolean[1]) {
|
|
i = 19;
|
|
} else if (i == 38 && aboolean[3] && aboolean[2]) {
|
|
i = 18;
|
|
} else if (i == 14 && !aboolean[0] && aboolean[1]) {
|
|
i = 31;
|
|
} else if (i == 25 && aboolean[0] && !aboolean[2]) {
|
|
i = 30;
|
|
} else if (i == 27 && !aboolean[3] && aboolean[1]) {
|
|
i = 41;
|
|
} else if (i == 38 && aboolean[3] && !aboolean[2]) {
|
|
i = 40;
|
|
} else if (i == 14 && aboolean[0] && !aboolean[1]) {
|
|
i = 29;
|
|
} else if (i == 25 && !aboolean[0] && aboolean[2]) {
|
|
i = 28;
|
|
} else if (i == 27 && aboolean[3] && !aboolean[1]) {
|
|
i = 43;
|
|
} else if (i == 38 && !aboolean[3] && aboolean[2]) {
|
|
i = 42;
|
|
} else if (i == 26 && aboolean[0] && aboolean[1] && aboolean[2] && aboolean[3]) {
|
|
i = 46;
|
|
} else if (i == 26 && !aboolean[0] && aboolean[1] && aboolean[2] && aboolean[3]) {
|
|
i = 9;
|
|
} else if (i == 26 && aboolean[0] && !aboolean[1] && aboolean[2] && aboolean[3]) {
|
|
i = 21;
|
|
} else if (i == 26 && aboolean[0] && aboolean[1] && !aboolean[2] && aboolean[3]) {
|
|
i = 8;
|
|
} else if (i == 26 && aboolean[0] && aboolean[1] && aboolean[2] && !aboolean[3]) {
|
|
i = 20;
|
|
} else if (i == 26 && aboolean[0] && aboolean[1] && !aboolean[2] && !aboolean[3]) {
|
|
i = 11;
|
|
} else if (i == 26 && !aboolean[0] && !aboolean[1] && aboolean[2] && aboolean[3]) {
|
|
i = 22;
|
|
} else if (i == 26 && !aboolean[0] && aboolean[1] && !aboolean[2] && aboolean[3]) {
|
|
i = 23;
|
|
} else if (i == 26 && aboolean[0] && !aboolean[1] && aboolean[2] && !aboolean[3]) {
|
|
i = 10;
|
|
} else if (i == 26 && aboolean[0] && !aboolean[1] && !aboolean[2] && aboolean[3]) {
|
|
i = 34;
|
|
} else if (i == 26 && !aboolean[0] && aboolean[1] && aboolean[2] && !aboolean[3]) {
|
|
i = 35;
|
|
} else if (i == 26 && aboolean[0] && !aboolean[1] && !aboolean[2] && !aboolean[3]) {
|
|
i = 32;
|
|
} else if (i == 26 && !aboolean[0] && aboolean[1] && !aboolean[2] && !aboolean[3]) {
|
|
i = 33;
|
|
} else if (i == 26 && !aboolean[0] && !aboolean[1] && aboolean[2] && !aboolean[3]) {
|
|
i = 44;
|
|
} else if (i == 26 && !aboolean[0] && !aboolean[1] && !aboolean[2] && aboolean[3]) {
|
|
i = 45;
|
|
}
|
|
|
|
return i;
|
|
}
|
|
}
|
|
|
|
private static void switchValues(int ix1, int ix2, boolean[] arr) {
|
|
boolean flag = arr[ix1];
|
|
arr[ix1] = arr[ix2];
|
|
arr[ix2] = flag;
|
|
}
|
|
|
|
private static boolean isNeighbourOverlay(ConnectedProperties cp, IBlockAccess iblockaccess, IBlockState blockState,
|
|
BlockPos blockPos, int side, EaglerTextureAtlasSprite icon, int metadata) {
|
|
IBlockState iblockstate = iblockaccess.getBlockState(blockPos);
|
|
|
|
if (!isFullCubeModel(iblockstate)) {
|
|
return false;
|
|
} else {
|
|
if (cp.connectBlocks != null) {
|
|
BlockStateBase blockstatebase = (BlockStateBase) iblockstate;
|
|
|
|
if (!Matches.block(blockstatebase.getBlockId(), blockstatebase.getMetadata(), cp.connectBlocks)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (cp.connectTileIcons != null) {
|
|
EaglerTextureAtlasSprite textureatlassprite = getNeighbourIcon(iblockaccess, blockState, blockPos,
|
|
iblockstate, side);
|
|
|
|
if (!Config.isSameOne(textureatlassprite, cp.connectTileIcons)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
IBlockState iblockstate1 = iblockaccess.getBlockState(blockPos.offset(getFacing(side)));
|
|
return iblockstate1.getBlock().isOpaqueCube() ? false
|
|
: (side == 1 && iblockstate1.getBlock() == Blocks.snow_layer ? false
|
|
: !isNeighbour(cp, iblockaccess, blockState, blockPos, iblockstate, side, icon, metadata));
|
|
}
|
|
}
|
|
|
|
private static boolean isFullCubeModel(IBlockState state) {
|
|
if (state.getBlock().isFullCube()) {
|
|
return true;
|
|
} else {
|
|
Block block = state.getBlock();
|
|
return block instanceof BlockGlass ? true : block instanceof BlockStainedGlass;
|
|
}
|
|
}
|
|
|
|
private static boolean isNeighbourMatching(ConnectedProperties cp, IBlockAccess iblockaccess,
|
|
IBlockState blockState, BlockPos blockPos, int side, EaglerTextureAtlasSprite icon, int metadata) {
|
|
IBlockState iblockstate = iblockaccess.getBlockState(blockPos);
|
|
|
|
if (iblockstate == AIR_DEFAULT_STATE) {
|
|
return false;
|
|
} else {
|
|
if (cp.matchBlocks != null && iblockstate instanceof BlockStateBase) {
|
|
BlockStateBase blockstatebase = (BlockStateBase) iblockstate;
|
|
|
|
if (!cp.matchesBlock(blockstatebase.getBlockId(), blockstatebase.getMetadata())) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (cp.matchTileIcons != null) {
|
|
EaglerTextureAtlasSprite textureatlassprite = getNeighbourIcon(iblockaccess, blockState, blockPos,
|
|
iblockstate, side);
|
|
|
|
if (textureatlassprite != icon) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
IBlockState iblockstate1 = iblockaccess.getBlockState(blockPos.offset(getFacing(side)));
|
|
return iblockstate1.getBlock().isOpaqueCube() ? false
|
|
: side != 1 || iblockstate1.getBlock() != Blocks.snow_layer;
|
|
}
|
|
}
|
|
|
|
private static boolean isNeighbour(ConnectedProperties cp, IBlockAccess iblockaccess, IBlockState blockState,
|
|
BlockPos blockPos, int side, EaglerTextureAtlasSprite icon, int metadata) {
|
|
IBlockState iblockstate = iblockaccess.getBlockState(blockPos);
|
|
return isNeighbour(cp, iblockaccess, blockState, blockPos, iblockstate, side, icon, metadata);
|
|
}
|
|
|
|
private static boolean isNeighbour(ConnectedProperties cp, IBlockAccess iblockaccess, IBlockState blockState,
|
|
BlockPos blockPos, IBlockState neighbourState, int side, EaglerTextureAtlasSprite icon, int metadata) {
|
|
if (blockState == neighbourState) {
|
|
return true;
|
|
} else if (cp.connect == 2) {
|
|
if (neighbourState == null) {
|
|
return false;
|
|
} else if (neighbourState == AIR_DEFAULT_STATE) {
|
|
return false;
|
|
} else {
|
|
EaglerTextureAtlasSprite textureatlassprite = getNeighbourIcon(iblockaccess, blockState, blockPos,
|
|
neighbourState, side);
|
|
return textureatlassprite == icon;
|
|
}
|
|
} else if (cp.connect == 3) {
|
|
return neighbourState == null ? false
|
|
: (neighbourState == AIR_DEFAULT_STATE ? false
|
|
: neighbourState.getBlock().getMaterial() == blockState.getBlock().getMaterial());
|
|
} else if (!(neighbourState instanceof BlockStateBase)) {
|
|
return false;
|
|
} else {
|
|
BlockStateBase blockstatebase = (BlockStateBase) neighbourState;
|
|
Block block = blockstatebase.getBlock();
|
|
int i = blockstatebase.getMetadata();
|
|
return block == blockState.getBlock() && i == metadata;
|
|
}
|
|
}
|
|
|
|
private static EaglerTextureAtlasSprite getNeighbourIcon(IBlockAccess iblockaccess, IBlockState blockState,
|
|
BlockPos blockPos, IBlockState neighbourState, int side) {
|
|
neighbourState = neighbourState.getBlock().getActualState(neighbourState, iblockaccess, blockPos);
|
|
IBakedModel ibakedmodel = Minecraft.getMinecraft().getBlockRendererDispatcher().getBlockModelShapes()
|
|
.getModelForState(neighbourState);
|
|
|
|
if (ibakedmodel == null) {
|
|
return null;
|
|
} else {
|
|
// if (Reflector.ForgeBlock_getExtendedState.exists()) {
|
|
// neighbourState = (IBlockState) Reflector.call(neighbourState.getBlock(),
|
|
// Reflector.ForgeBlock_getExtendedState, new Object[] { neighbourState, iblockaccess, blockPos });
|
|
// }
|
|
|
|
EnumFacing enumfacing = getFacing(side);
|
|
List list = ibakedmodel.getFaceQuads(enumfacing);
|
|
|
|
if (list == null) {
|
|
return null;
|
|
} else {
|
|
if (Config.isBetterGrass()) {
|
|
list = BetterGrass.getFaceQuads(iblockaccess, neighbourState, blockPos, enumfacing, list);
|
|
}
|
|
|
|
if (list.size() > 0) {
|
|
BakedQuad bakedquad1 = (BakedQuad) list.get(0);
|
|
return bakedquad1.getSprite();
|
|
} else {
|
|
List list1 = ibakedmodel.getGeneralQuads();
|
|
|
|
if (list1 == null) {
|
|
return null;
|
|
} else {
|
|
for (int i = 0; i < list1.size(); ++i) {
|
|
BakedQuad bakedquad = (BakedQuad) list1.get(i);
|
|
|
|
if (bakedquad.getFace() == enumfacing) {
|
|
return bakedquad.getSprite();
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private static EaglerTextureAtlasSprite getConnectedTextureHorizontal(ConnectedProperties cp,
|
|
IBlockAccess blockAccess, IBlockState blockState, BlockPos blockPos, int vertAxis, int side,
|
|
EaglerTextureAtlasSprite icon, int metadata) {
|
|
boolean flag;
|
|
boolean flag1;
|
|
flag = false;
|
|
flag1 = false;
|
|
label0:
|
|
|
|
switch (vertAxis) {
|
|
case 0:
|
|
switch (side) {
|
|
case 0:
|
|
flag = isNeighbour(cp, blockAccess, blockState, blockPos.west(), side, icon, metadata);
|
|
flag1 = isNeighbour(cp, blockAccess, blockState, blockPos.east(), side, icon, metadata);
|
|
break label0;
|
|
|
|
case 1:
|
|
flag = isNeighbour(cp, blockAccess, blockState, blockPos.west(), side, icon, metadata);
|
|
flag1 = isNeighbour(cp, blockAccess, blockState, blockPos.east(), side, icon, metadata);
|
|
break label0;
|
|
|
|
case 2:
|
|
flag = isNeighbour(cp, blockAccess, blockState, blockPos.east(), side, icon, metadata);
|
|
flag1 = isNeighbour(cp, blockAccess, blockState, blockPos.west(), side, icon, metadata);
|
|
break label0;
|
|
|
|
case 3:
|
|
flag = isNeighbour(cp, blockAccess, blockState, blockPos.west(), side, icon, metadata);
|
|
flag1 = isNeighbour(cp, blockAccess, blockState, blockPos.east(), side, icon, metadata);
|
|
break label0;
|
|
|
|
case 4:
|
|
flag = isNeighbour(cp, blockAccess, blockState, blockPos.north(), side, icon, metadata);
|
|
flag1 = isNeighbour(cp, blockAccess, blockState, blockPos.south(), side, icon, metadata);
|
|
break label0;
|
|
|
|
case 5:
|
|
flag = isNeighbour(cp, blockAccess, blockState, blockPos.south(), side, icon, metadata);
|
|
flag1 = isNeighbour(cp, blockAccess, blockState, blockPos.north(), side, icon, metadata);
|
|
|
|
default:
|
|
break label0;
|
|
}
|
|
|
|
case 1:
|
|
switch (side) {
|
|
case 0:
|
|
flag = isNeighbour(cp, blockAccess, blockState, blockPos.east(), side, icon, metadata);
|
|
flag1 = isNeighbour(cp, blockAccess, blockState, blockPos.west(), side, icon, metadata);
|
|
break label0;
|
|
|
|
case 1:
|
|
flag = isNeighbour(cp, blockAccess, blockState, blockPos.west(), side, icon, metadata);
|
|
flag1 = isNeighbour(cp, blockAccess, blockState, blockPos.east(), side, icon, metadata);
|
|
break label0;
|
|
|
|
case 2:
|
|
flag = isNeighbour(cp, blockAccess, blockState, blockPos.west(), side, icon, metadata);
|
|
flag1 = isNeighbour(cp, blockAccess, blockState, blockPos.east(), side, icon, metadata);
|
|
break label0;
|
|
|
|
case 3:
|
|
flag = isNeighbour(cp, blockAccess, blockState, blockPos.west(), side, icon, metadata);
|
|
flag1 = isNeighbour(cp, blockAccess, blockState, blockPos.east(), side, icon, metadata);
|
|
break label0;
|
|
|
|
case 4:
|
|
flag = isNeighbour(cp, blockAccess, blockState, blockPos.down(), side, icon, metadata);
|
|
flag1 = isNeighbour(cp, blockAccess, blockState, blockPos.up(), side, icon, metadata);
|
|
break label0;
|
|
|
|
case 5:
|
|
flag = isNeighbour(cp, blockAccess, blockState, blockPos.up(), side, icon, metadata);
|
|
flag1 = isNeighbour(cp, blockAccess, blockState, blockPos.down(), side, icon, metadata);
|
|
|
|
default:
|
|
break label0;
|
|
}
|
|
|
|
case 2:
|
|
switch (side) {
|
|
case 0:
|
|
flag = isNeighbour(cp, blockAccess, blockState, blockPos.south(), side, icon, metadata);
|
|
flag1 = isNeighbour(cp, blockAccess, blockState, blockPos.north(), side, icon, metadata);
|
|
break;
|
|
|
|
case 1:
|
|
flag = isNeighbour(cp, blockAccess, blockState, blockPos.north(), side, icon, metadata);
|
|
flag1 = isNeighbour(cp, blockAccess, blockState, blockPos.south(), side, icon, metadata);
|
|
break;
|
|
|
|
case 2:
|
|
flag = isNeighbour(cp, blockAccess, blockState, blockPos.down(), side, icon, metadata);
|
|
flag1 = isNeighbour(cp, blockAccess, blockState, blockPos.up(), side, icon, metadata);
|
|
break;
|
|
|
|
case 3:
|
|
flag = isNeighbour(cp, blockAccess, blockState, blockPos.up(), side, icon, metadata);
|
|
flag1 = isNeighbour(cp, blockAccess, blockState, blockPos.down(), side, icon, metadata);
|
|
break;
|
|
|
|
case 4:
|
|
flag = isNeighbour(cp, blockAccess, blockState, blockPos.north(), side, icon, metadata);
|
|
flag1 = isNeighbour(cp, blockAccess, blockState, blockPos.south(), side, icon, metadata);
|
|
break;
|
|
|
|
case 5:
|
|
flag = isNeighbour(cp, blockAccess, blockState, blockPos.north(), side, icon, metadata);
|
|
flag1 = isNeighbour(cp, blockAccess, blockState, blockPos.south(), side, icon, metadata);
|
|
}
|
|
}
|
|
|
|
int i = 3;
|
|
|
|
if (flag) {
|
|
if (flag1) {
|
|
i = 1;
|
|
} else {
|
|
i = 2;
|
|
}
|
|
} else if (flag1) {
|
|
i = 0;
|
|
} else {
|
|
i = 3;
|
|
}
|
|
|
|
return cp.tileIcons[i];
|
|
}
|
|
|
|
private static EaglerTextureAtlasSprite getConnectedTextureVertical(ConnectedProperties cp,
|
|
IBlockAccess blockAccess, IBlockState blockState, BlockPos blockPos, int vertAxis, int side,
|
|
EaglerTextureAtlasSprite icon, int metadata) {
|
|
boolean flag = false;
|
|
boolean flag1 = false;
|
|
|
|
switch (vertAxis) {
|
|
case 0:
|
|
if (side == 1) {
|
|
flag = isNeighbour(cp, blockAccess, blockState, blockPos.south(), side, icon, metadata);
|
|
flag1 = isNeighbour(cp, blockAccess, blockState, blockPos.north(), side, icon, metadata);
|
|
} else if (side == 0) {
|
|
flag = isNeighbour(cp, blockAccess, blockState, blockPos.north(), side, icon, metadata);
|
|
flag1 = isNeighbour(cp, blockAccess, blockState, blockPos.south(), side, icon, metadata);
|
|
} else {
|
|
flag = isNeighbour(cp, blockAccess, blockState, blockPos.down(), side, icon, metadata);
|
|
flag1 = isNeighbour(cp, blockAccess, blockState, blockPos.up(), side, icon, metadata);
|
|
}
|
|
|
|
break;
|
|
|
|
case 1:
|
|
if (side == 3) {
|
|
flag = isNeighbour(cp, blockAccess, blockState, blockPos.down(), side, icon, metadata);
|
|
flag1 = isNeighbour(cp, blockAccess, blockState, blockPos.up(), side, icon, metadata);
|
|
} else if (side == 2) {
|
|
flag = isNeighbour(cp, blockAccess, blockState, blockPos.up(), side, icon, metadata);
|
|
flag1 = isNeighbour(cp, blockAccess, blockState, blockPos.down(), side, icon, metadata);
|
|
} else {
|
|
flag = isNeighbour(cp, blockAccess, blockState, blockPos.south(), side, icon, metadata);
|
|
flag1 = isNeighbour(cp, blockAccess, blockState, blockPos.north(), side, icon, metadata);
|
|
}
|
|
|
|
break;
|
|
|
|
case 2:
|
|
if (side == 5) {
|
|
flag = isNeighbour(cp, blockAccess, blockState, blockPos.up(), side, icon, metadata);
|
|
flag1 = isNeighbour(cp, blockAccess, blockState, blockPos.down(), side, icon, metadata);
|
|
} else if (side == 4) {
|
|
flag = isNeighbour(cp, blockAccess, blockState, blockPos.down(), side, icon, metadata);
|
|
flag1 = isNeighbour(cp, blockAccess, blockState, blockPos.up(), side, icon, metadata);
|
|
} else {
|
|
flag = isNeighbour(cp, blockAccess, blockState, blockPos.west(), side, icon, metadata);
|
|
flag1 = isNeighbour(cp, blockAccess, blockState, blockPos.east(), side, icon, metadata);
|
|
}
|
|
}
|
|
|
|
int i = 3;
|
|
|
|
if (flag) {
|
|
if (flag1) {
|
|
i = 1;
|
|
} else {
|
|
i = 2;
|
|
}
|
|
} else if (flag1) {
|
|
i = 0;
|
|
} else {
|
|
i = 3;
|
|
}
|
|
|
|
return cp.tileIcons[i];
|
|
}
|
|
|
|
private static EaglerTextureAtlasSprite getConnectedTextureHorizontalVertical(ConnectedProperties cp,
|
|
IBlockAccess blockAccess, IBlockState blockState, BlockPos blockPos, int vertAxis, int side,
|
|
EaglerTextureAtlasSprite icon, int metadata) {
|
|
EaglerTextureAtlasSprite[] atextureatlassprite = cp.tileIcons;
|
|
EaglerTextureAtlasSprite textureatlassprite = getConnectedTextureHorizontal(cp, blockAccess, blockState,
|
|
blockPos, vertAxis, side, icon, metadata);
|
|
|
|
if (textureatlassprite != null && textureatlassprite != icon && textureatlassprite != atextureatlassprite[3]) {
|
|
return textureatlassprite;
|
|
} else {
|
|
EaglerTextureAtlasSprite textureatlassprite1 = getConnectedTextureVertical(cp, blockAccess, blockState,
|
|
blockPos, vertAxis, side, icon, metadata);
|
|
return textureatlassprite1 == atextureatlassprite[0] ? atextureatlassprite[4]
|
|
: (textureatlassprite1 == atextureatlassprite[1] ? atextureatlassprite[5]
|
|
: (textureatlassprite1 == atextureatlassprite[2] ? atextureatlassprite[6]
|
|
: textureatlassprite1));
|
|
}
|
|
}
|
|
|
|
private static EaglerTextureAtlasSprite getConnectedTextureVerticalHorizontal(ConnectedProperties cp,
|
|
IBlockAccess blockAccess, IBlockState blockState, BlockPos blockPos, int vertAxis, int side,
|
|
EaglerTextureAtlasSprite icon, int metadata) {
|
|
EaglerTextureAtlasSprite[] atextureatlassprite = cp.tileIcons;
|
|
EaglerTextureAtlasSprite textureatlassprite = getConnectedTextureVertical(cp, blockAccess, blockState, blockPos,
|
|
vertAxis, side, icon, metadata);
|
|
|
|
if (textureatlassprite != null && textureatlassprite != icon && textureatlassprite != atextureatlassprite[3]) {
|
|
return textureatlassprite;
|
|
} else {
|
|
EaglerTextureAtlasSprite textureatlassprite1 = getConnectedTextureHorizontal(cp, blockAccess, blockState,
|
|
blockPos, vertAxis, side, icon, metadata);
|
|
return textureatlassprite1 == atextureatlassprite[0] ? atextureatlassprite[4]
|
|
: (textureatlassprite1 == atextureatlassprite[1] ? atextureatlassprite[5]
|
|
: (textureatlassprite1 == atextureatlassprite[2] ? atextureatlassprite[6]
|
|
: textureatlassprite1));
|
|
}
|
|
}
|
|
|
|
private static EaglerTextureAtlasSprite getConnectedTextureTop(ConnectedProperties cp, IBlockAccess blockAccess,
|
|
IBlockState blockState, BlockPos blockPos, int vertAxis, int side, EaglerTextureAtlasSprite icon,
|
|
int metadata) {
|
|
boolean flag = false;
|
|
|
|
switch (vertAxis) {
|
|
case 0:
|
|
if (side == 1 || side == 0) {
|
|
return null;
|
|
}
|
|
|
|
flag = isNeighbour(cp, blockAccess, blockState, blockPos.up(), side, icon, metadata);
|
|
break;
|
|
|
|
case 1:
|
|
if (side == 3 || side == 2) {
|
|
return null;
|
|
}
|
|
|
|
flag = isNeighbour(cp, blockAccess, blockState, blockPos.south(), side, icon, metadata);
|
|
break;
|
|
|
|
case 2:
|
|
if (side == 5 || side == 4) {
|
|
return null;
|
|
}
|
|
|
|
flag = isNeighbour(cp, blockAccess, blockState, blockPos.east(), side, icon, metadata);
|
|
}
|
|
|
|
if (flag) {
|
|
return cp.tileIcons[0];
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public static void updateIcons(TextureMap textureMap) {
|
|
blockProperties = (ConnectedProperties[][]) null;
|
|
tileProperties = (ConnectedProperties[][]) null;
|
|
spriteQuadMaps = null;
|
|
spriteQuadCompactMaps = (Map[][]) null;
|
|
|
|
if (Config.isConnectedTextures()) {
|
|
IResourcePack[] airesourcepack = Config.getResourcePacks();
|
|
|
|
for (int i = airesourcepack.length - 1; i >= 0; --i) {
|
|
IResourcePack iresourcepack = airesourcepack[i];
|
|
updateIcons(textureMap, iresourcepack);
|
|
}
|
|
|
|
updateIcons(textureMap, Minecraft.getMinecraft().getDefaultResourcePack());
|
|
ResourceLocation resourcelocation = new ResourceLocation("mcpatcher/ctm/default/empty");
|
|
emptySprite = textureMap.registerSprite(resourcelocation);
|
|
spriteQuadMaps = new Map[textureMap.getCountRegisteredSprites() + 1];
|
|
spriteQuadFullMaps = new Map[textureMap.getCountRegisteredSprites() + 1];
|
|
spriteQuadCompactMaps = new Map[textureMap.getCountRegisteredSprites() + 1][];
|
|
|
|
if (blockProperties.length <= 0) {
|
|
blockProperties = (ConnectedProperties[][]) null;
|
|
}
|
|
|
|
if (tileProperties.length <= 0) {
|
|
tileProperties = (ConnectedProperties[][]) null;
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void updateIconEmpty(TextureMap textureMap) {
|
|
}
|
|
|
|
public static void updateIcons(TextureMap textureMap, IResourcePack rp) {
|
|
List<String> astring = ResUtils.collectPropertyFiles(rp, "mcpatcher/ctm/");
|
|
Collections.sort(astring);
|
|
List list = makePropertyList(tileProperties);
|
|
List list1 = makePropertyList(blockProperties);
|
|
|
|
for (int i = 0, l = astring.size(); i < l; ++i) {
|
|
String s = astring.get(i);
|
|
Config.dbg("ConnectedTextures: " + s);
|
|
|
|
try {
|
|
ResourceLocation resourcelocation = new ResourceLocation(s);
|
|
InputStream inputstream = rp.getInputStream(resourcelocation);
|
|
|
|
if (inputstream == null) {
|
|
Config.warn("ConnectedTextures file not found: " + s);
|
|
} else {
|
|
Properties properties = new PropertiesOrdered();
|
|
properties.load(inputstream);
|
|
inputstream.close();
|
|
ConnectedProperties connectedproperties = new ConnectedProperties(properties, s);
|
|
|
|
if (connectedproperties.isValid(s)) {
|
|
connectedproperties.updateIcons(textureMap);
|
|
addToTileList(connectedproperties, list);
|
|
addToBlockList(connectedproperties, list1);
|
|
}
|
|
}
|
|
} catch (FileNotFoundException var11) {
|
|
Config.warn("ConnectedTextures file not found: " + s);
|
|
} catch (Exception exception) {
|
|
exception.printStackTrace();
|
|
}
|
|
}
|
|
|
|
blockProperties = propertyListToArray(list1);
|
|
tileProperties = propertyListToArray(list);
|
|
multipass = detectMultipass();
|
|
Config.dbg("Multipass connected textures: " + multipass);
|
|
}
|
|
|
|
private static List makePropertyList(ConnectedProperties[][] propsArr) {
|
|
List list = new ArrayList();
|
|
|
|
if (propsArr != null) {
|
|
for (int i = 0; i < propsArr.length; ++i) {
|
|
ConnectedProperties[] aconnectedproperties = propsArr[i];
|
|
List list1 = null;
|
|
|
|
if (aconnectedproperties != null) {
|
|
list1 = new ArrayList(Arrays.asList(aconnectedproperties));
|
|
}
|
|
|
|
list.add(list1);
|
|
}
|
|
}
|
|
|
|
return list;
|
|
}
|
|
|
|
private static boolean detectMultipass() {
|
|
List list = new ArrayList();
|
|
|
|
for (int i = 0; i < tileProperties.length; ++i) {
|
|
ConnectedProperties[] aconnectedproperties = tileProperties[i];
|
|
|
|
if (aconnectedproperties != null) {
|
|
list.addAll(Arrays.asList(aconnectedproperties));
|
|
}
|
|
}
|
|
|
|
for (int k = 0; k < blockProperties.length; ++k) {
|
|
ConnectedProperties[] aconnectedproperties2 = blockProperties[k];
|
|
|
|
if (aconnectedproperties2 != null) {
|
|
list.addAll(Arrays.asList(aconnectedproperties2));
|
|
}
|
|
}
|
|
|
|
ConnectedProperties[] aconnectedproperties1 = (ConnectedProperties[]) ((ConnectedProperties[]) list
|
|
.toArray(new ConnectedProperties[list.size()]));
|
|
Set set1 = new HashSet();
|
|
Set set = new HashSet();
|
|
|
|
for (int j = 0; j < aconnectedproperties1.length; ++j) {
|
|
ConnectedProperties connectedproperties = aconnectedproperties1[j];
|
|
|
|
if (connectedproperties.matchTileIcons != null) {
|
|
set1.addAll(Arrays.asList(connectedproperties.matchTileIcons));
|
|
}
|
|
|
|
if (connectedproperties.tileIcons != null) {
|
|
set.addAll(Arrays.asList(connectedproperties.tileIcons));
|
|
}
|
|
}
|
|
|
|
set1.retainAll(set);
|
|
return !set1.isEmpty();
|
|
}
|
|
|
|
private static ConnectedProperties[][] propertyListToArray(List list) {
|
|
ConnectedProperties[][] aconnectedproperties = new ConnectedProperties[list.size()][];
|
|
|
|
for (int i = 0; i < list.size(); ++i) {
|
|
List list2 = (List) list.get(i);
|
|
|
|
if (list2 != null) {
|
|
ConnectedProperties[] aconnectedproperties1 = (ConnectedProperties[]) list2
|
|
.toArray(new ConnectedProperties[list2.size()]);
|
|
aconnectedproperties[i] = aconnectedproperties1;
|
|
}
|
|
}
|
|
|
|
return aconnectedproperties;
|
|
}
|
|
|
|
private static void addToTileList(ConnectedProperties cp, List tileList) {
|
|
if (cp.matchTileIcons != null) {
|
|
for (int i = 0; i < cp.matchTileIcons.length; ++i) {
|
|
EaglerTextureAtlasSprite textureatlassprite = cp.matchTileIcons[i];
|
|
int j = textureatlassprite.getIndexInMap();
|
|
|
|
if (j < 0) {
|
|
Config.warn("Invalid tile ID: " + j + ", icon: " + textureatlassprite.getIconName());
|
|
} else {
|
|
addToList(cp, tileList, j);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void addToBlockList(ConnectedProperties cp, List blockList) {
|
|
if (cp.matchBlocks != null) {
|
|
for (int i = 0; i < cp.matchBlocks.length; ++i) {
|
|
int j = cp.matchBlocks[i].getBlockId();
|
|
|
|
if (j < 0) {
|
|
Config.warn("Invalid block ID: " + j);
|
|
} else {
|
|
addToList(cp, blockList, j);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void addToList(ConnectedProperties cp, List list, int id) {
|
|
while (id >= list.size()) {
|
|
list.add(null);
|
|
}
|
|
|
|
List list1 = (List) list.get(id);
|
|
|
|
if (list1 == null) {
|
|
list1 = new ArrayList();
|
|
list.set(id, list1);
|
|
}
|
|
|
|
list1.add(cp);
|
|
}
|
|
|
|
}
|