From 840af06f431e1676835faaa903ae41b5bf045547 Mon Sep 17 00:00:00 2001 From: aidancbrady Date: Thu, 5 May 2016 22:52:57 -0400 Subject: [PATCH] Fixed up some textures, start working on a CTM rewrite --- .../client/render/ctm/BlockRenderTypeCTM.java | 24 + .../java/mekanism/client/render/ctm/CTM.java | 299 ++++++++++++ .../render/ctm/CTMBlockRenderContext.java | 28 ++ .../client/render/ctm/ChiselFace.java | 85 ++++ .../client/render/ctm/ChiselTextureCTM.java | 59 +++ .../java/mekanism/client/render/ctm/Dir.java | 186 ++++++++ .../mekanism/client/render/ctm/ICTMBlock.java | 5 + .../mekanism/client/render/ctm/ISubmap.java | 24 + .../mekanism/client/render/ctm/ModelCTM.java | 143 ++++++ .../client/render/ctm/ModelChisel.java | 107 +++++ .../client/render/ctm/ModelChiselBlock.java | 156 +++++++ .../render/ctm/PropertyCTMRenderContext.java | 29 ++ .../java/mekanism/client/render/ctm/Quad.java | 439 ++++++++++++++++++ .../mekanism/client/render/ctm/Submap.java | 94 ++++ .../render/ctm/TextureSpriteCallback.java | 24 + .../render/tileentity/RenderEnergyCube.java | 7 +- .../mekanism/common/block/BlockBasic.java | 16 +- .../common/tile/TileEntityBasicBlock.java | 6 +- .../chemical_injection_chamber.json | 13 +- .../assets/mekanism/blockstates/combiner.json | 13 +- .../assets/mekanism/blockstates/crusher.json | 13 +- .../blockstates/enrichment_chamber.json | 13 +- .../textures/blocks/crusher/CrusherBottom.png | Bin 0 -> 1427 bytes 23 files changed, 1755 insertions(+), 28 deletions(-) create mode 100644 src/main/java/mekanism/client/render/ctm/BlockRenderTypeCTM.java create mode 100644 src/main/java/mekanism/client/render/ctm/CTM.java create mode 100644 src/main/java/mekanism/client/render/ctm/CTMBlockRenderContext.java create mode 100644 src/main/java/mekanism/client/render/ctm/ChiselFace.java create mode 100644 src/main/java/mekanism/client/render/ctm/ChiselTextureCTM.java create mode 100644 src/main/java/mekanism/client/render/ctm/Dir.java create mode 100644 src/main/java/mekanism/client/render/ctm/ICTMBlock.java create mode 100644 src/main/java/mekanism/client/render/ctm/ISubmap.java create mode 100644 src/main/java/mekanism/client/render/ctm/ModelCTM.java create mode 100644 src/main/java/mekanism/client/render/ctm/ModelChisel.java create mode 100644 src/main/java/mekanism/client/render/ctm/ModelChiselBlock.java create mode 100644 src/main/java/mekanism/client/render/ctm/PropertyCTMRenderContext.java create mode 100644 src/main/java/mekanism/client/render/ctm/Quad.java create mode 100644 src/main/java/mekanism/client/render/ctm/Submap.java create mode 100644 src/main/java/mekanism/client/render/ctm/TextureSpriteCallback.java create mode 100644 src/main/resources/assets/mekanism/textures/blocks/crusher/CrusherBottom.png diff --git a/src/main/java/mekanism/client/render/ctm/BlockRenderTypeCTM.java b/src/main/java/mekanism/client/render/ctm/BlockRenderTypeCTM.java new file mode 100644 index 000000000..e07ae883c --- /dev/null +++ b/src/main/java/mekanism/client/render/ctm/BlockRenderTypeCTM.java @@ -0,0 +1,24 @@ +package mekanism.client.render.ctm; + +import net.minecraft.util.BlockPos; +import net.minecraft.util.EnumWorldBlockLayer; +import net.minecraft.world.IBlockAccess; + +public class BlockRenderTypeCTM { + + public ChiselTextureCTM makeTexture(EnumWorldBlockLayer layer, TextureSpriteCallback... sprites) { + return new ChiselTextureCTM(this, layer, sprites); + } + + public CTMBlockRenderContext getBlockRenderContext(IBlockAccess world, BlockPos pos) { + return new CTMBlockRenderContext(world, pos); + } + + public int getQuadsPerSide() { + return 4; + } + + public int requiredTextures() { + return 2; + } +} diff --git a/src/main/java/mekanism/client/render/ctm/CTM.java b/src/main/java/mekanism/client/render/ctm/CTM.java new file mode 100644 index 000000000..93de634b5 --- /dev/null +++ b/src/main/java/mekanism/client/render/ctm/CTM.java @@ -0,0 +1,299 @@ +package mekanism.client.render.ctm; + +import gnu.trove.map.TIntObjectMap; +import gnu.trove.map.hash.TIntObjectHashMap; + +import java.util.EnumMap; + +import net.minecraft.block.state.IBlockState; +import net.minecraft.util.BlockPos; +import net.minecraft.util.EnumFacing; +import net.minecraft.world.IBlockAccess; + +import com.google.common.base.Optional; +import com.google.common.collect.Maps; + +import static mekanism.client.render.ctm.Dir.*; + +// @formatter:off +/** + * The CTM renderer will draw the block's FACE using by assembling 4 quadrants from the 5 available block + * textures. The normal Texture.png is the blocks "unconnected" texture, and is used when CTM is disabled or the block + * has nothing to connect to. This texture has all of the outside corner quadrants The texture-ctm.png contains the + * rest of the quadrants. + *
+ * ┌─────────────────┐ ┌────────────────────────────────┐ + * │ texture.png │ │ texture-ctm.png │ + * │ ╔══════╤══════╗ │ │ ──────┼────── ║ ─────┼───── ║ │ + * │ ║ │ ║ │ │ │ │ │║ │ ║ │ + * │ ║ 16 │ 17 ║ │ │ │ 0 │ 1 │║ 2 │ 3 ║ │ + * │ ╟──────┼──────╢ │ │ ┼──────┼──────┼╟──────┼──────╢ │ + * │ ║ │ ║ │ │ │ │ │║ │ ║ │ + * │ ║ 18 │ 19 ║ │ │ │ 4 │ 5 │║ 6 │ 7 ║ │ + * │ ╚══════╧══════╝ │ │ ──────┼────── ║ ─────┼───── ║ │ + * └─────────────────┘ │ ═══════╤═══════╝ ─────┼───── ╚ │ + * │ │ │ ││ │ │ │ + * │ │ 8 │ 9 ││ 10 │ 11 │ │ + * │ ┼──────┼──────┼┼──────┼──────┼ │ + * │ │ │ ││ │ │ │ + * │ │ 12 │ 13 ││ 14 │ 15 │ │ + * │ ═══════╧═══════╗ ─────┼───── ╔ │ + * └────────────────────────────────┘ + *
+ * combining { 18, 13, 9, 16 }, we can generate a texture connected to the right! + *
+ * ╔══════╤═══════ + * ║ │ │ + * ║ 16 │ 9 │ + * ╟──────┼──────┼ + * ║ │ │ + * ║ 18 │ 13 │ + * ╚══════╧═══════ + *
+ * + * combining { 18, 13, 11, 2 }, we can generate a texture, in the shape of an L (connected to the right, and up + *
+ * ║ ─────┼───── ╚ + * ║ │ │ + * ║ 2 │ 11 │ + * ╟──────┼──────┼ + * ║ │ │ + * ║ 18 │ 13 │ + * ╚══════╧═══════ + *
+ * + * HAVE FUN! + * -CptRageToaster- + */ +public class CTM { + + /** + * The Uvs for the specific "magic number" value + */ + public static final ISubmap[] uvs = new ISubmap[]{ + //Ctm texture + new Submap(4, 4, 0, 0), // 0 + new Submap(4, 4, 4, 0), // 1 + new Submap(4, 4, 8, 0), // 2 + new Submap(4, 4, 12, 0), // 3 + new Submap(4, 4, 0, 4), // 4 + new Submap(4, 4, 4, 4), // 5 + new Submap(4, 4, 8, 4), // 6 + new Submap(4, 4, 12, 4), // 7 + new Submap(4, 4, 0, 8), // 8 + new Submap(4, 4, 4, 8), // 9 + new Submap(4, 4, 8, 8), // 10 + new Submap(4, 4, 12, 8), // 11 + new Submap(4, 4, 0, 12), // 12 + new Submap(4, 4, 4, 12), // 13 + new Submap(4, 4, 8, 12), // 14 + new Submap(4, 4, 12, 12), // 15 + // Default texture + new Submap(8, 8, 0, 0), // 16 + new Submap(8, 8, 8, 0), // 17 + new Submap(8, 8, 0, 8), // 18 + new Submap(8, 8, 8, 8) // 19 + }; + + public static final ISubmap FULL_TEXTURE = new Submap(16, 16, 0, 0); + + // @formatter:on + + /** Some hardcoded offset values for the different corner indeces */ + protected static int[] submapOffsets = { 4, 5, 1, 0 }; + /** For use via the Chisel 2 config only, altering this could cause unintended behavior */ + public static boolean disableObscuredFaceCheckConfig = false; + + public Optional disableObscuredFaceCheck = Optional.absent(); + + protected TIntObjectMap submapMap = new TIntObjectHashMap(); + protected EnumMap connectionMap = Maps.newEnumMap(Dir.class); + protected int[] submapCache; + + protected CTM() { + for (Dir dir : Dir.VALUES) { + connectionMap.put(dir, false); + } + + // Mapping the different corner indeces to their respective dirs + submapMap.put(0, new Dir[] { BOTTOM, LEFT, BOTTOM_LEFT }); + submapMap.put(1, new Dir[] { BOTTOM, RIGHT, BOTTOM_RIGHT }); + submapMap.put(2, new Dir[] { TOP, RIGHT, TOP_RIGHT }); + submapMap.put(3, new Dir[] { TOP, LEFT, TOP_LEFT }); + } + + public static CTM getInstance() { + return new CTM(); + } + + /** + * @return The indeces of the typical 4x4 submap to use for the given face at the given location. + * + * Indeces are in counter-clockwise order starting at bottom left. + */ + public int[] createSubmapIndices(IBlockAccess world, BlockPos pos, EnumFacing side) { + submapCache = new int[] { 18, 19, 17, 16 }; + + if (world == null) { + return submapCache; + } + + buildConnectionMap(world, pos, side); + + // Map connections to submap indeces + for (int i = 0; i < 4; i++) { + fillSubmaps(i); + } + + return submapCache; + } + + public int[] getSubmapIndices() { + return submapCache; + } + + public static boolean isDefaultTexture(int id) { + return (id == 16 || id == 17 || id == 18 || id == 19); + } + + /** + * Builds the connection map and stores it in this CTM instance. The {@link #connected(Dir)}, {@link #connectedAnd(Dir...)}, and {@link #connectedOr(Dir...)} methods can be used to access it. + */ + public void buildConnectionMap(IBlockAccess world, BlockPos pos, EnumFacing side) { + IBlockState state = world.getBlockState(pos); + for (Dir dir : Dir.VALUES) { + connectionMap.put(dir, dir.isConnected(this, world, pos, side, state)); + } + } + + private void fillSubmaps(int idx) { + Dir[] dirs = submapMap.get(idx); + if (connectedOr(dirs[0], dirs[1])) { + if (connectedAnd(dirs)) { + // If all dirs are connected, we use the fully connected face, + // the base offset value. + submapCache[idx] = submapOffsets[idx]; + } else { + // This is a bit magic-y, but basically the array is ordered so + // the first dir requires an offset of 2, and the second dir + // requires an offset of 8, plus the initial offset for the + // corner. + submapCache[idx] = submapOffsets[idx] + (connected(dirs[0]) ? 2 : 0) + (connected(dirs[1]) ? 8 : 0); + } + } + } + + /** + * @param dir + * The direction to check connection in. + * @return True if the cached connectionMap holds a connection in this {@link Dir direction}. + */ + public boolean connected(Dir dir) { + return connectionMap.get(dir); + } + + /** + * @param dirs + * The directions to check connection in. + * @return True if the cached connectionMap holds a connection in all the given {@link Dir directions}. + */ + public boolean connectedAnd(Dir... dirs) { + for (Dir dir : dirs) { + if (!connected(dir)) { + return false; + } + } + return true; + } + + /** + * @param dirs + * The directions to check connection in. + * @return True if the cached connectionMap holds a connection in one of the given {@link Dir directions}. + */ + public boolean connectedOr(Dir... dirs) { + for (Dir dir : dirs) { + if (connected(dir)) { + return true; + } + } + return false; + } + + /** + * A simple check for if the given block can connect to the given direction on the given side. + * + * @param world + * @param current + * The position of your block. + * @param y + * The position of the block to check against. + * @param dir + * The {@link EnumFacing side} of the block to check for connection status. This is not the direction to check in. + * @return True if the given block can connect to the given location on the given side. + */ + public boolean isConnected(IBlockAccess world, BlockPos current, BlockPos connection, EnumFacing dir) { + + IBlockState state = world.getBlockState(current); + return isConnected(world, current, connection, dir, state); + } + + /** + * A simple check for if the given block can connect to the given direction on the given side. + * + * @param world + * @param current + * The position of your block. + * @param y + * The position of the block to check against. + * @param dir + * The {@link EnumFacing side} of the block to check for connection status. This is not the direction to check in. + * @param state + * The state to check against for connection. + * @return True if the given block can connect to the given location on the given side. + */ + public boolean isConnected(IBlockAccess world, BlockPos current, BlockPos connection, EnumFacing dir, IBlockState state) { + +// if (CTMLib.chiselLoaded() && connectionBlocked(world, x, y, z, dir.ordinal())) { +// return false; +// } + + BlockPos pos2 = connection.add(dir.getDirectionVec()); + + boolean disableObscured = disableObscuredFaceCheck.or(disableObscuredFaceCheckConfig); + + IBlockState con = getBlockOrFacade(world, connection, dir); + IBlockState obscuring = disableObscured ? null : getBlockOrFacade(world, pos2, dir); + + // no block or a bad API user + if (con == null) { + return false; + } + + // TODO VERY TEMPORARY + boolean ret = con.getBlock() == state.getBlock(); + + // no block obscuring this face + if (obscuring == null) { + return ret; + } + + // check that we aren't already connected outwards from this side + ret &= !obscuring.getBlock().isFullCube() || !obscuring.equals(state); + + return ret; + } + +// private boolean connectionBlocked(IBlockAccess world, int x, int y, int z, int side) { +// Block block = world.getBlock(x, y, z); +// if (block instanceof IConnectable) { +// return !((IConnectable) block).canConnectCTM(world, x, y, z, side); +// } +// return false; +// } + + public IBlockState getBlockOrFacade(IBlockAccess world, BlockPos pos, EnumFacing side) { + IBlockState state = world.getBlockState(pos); + return state; + } +} \ No newline at end of file diff --git a/src/main/java/mekanism/client/render/ctm/CTMBlockRenderContext.java b/src/main/java/mekanism/client/render/ctm/CTMBlockRenderContext.java new file mode 100644 index 000000000..20c351bbc --- /dev/null +++ b/src/main/java/mekanism/client/render/ctm/CTMBlockRenderContext.java @@ -0,0 +1,28 @@ +package mekanism.client.render.ctm; + +import java.util.EnumMap; + +import net.minecraft.util.BlockPos; +import net.minecraft.util.EnumFacing; +import net.minecraft.world.IBlockAccess; + +public class CTMBlockRenderContext { + + private EnumMap ctmData = new EnumMap<>(EnumFacing.class); + + public CTMBlockRenderContext(IBlockAccess world, BlockPos pos) { + for (EnumFacing face : EnumFacing.VALUES) { + CTM ctm = createCTM(); + ctm.createSubmapIndices(world, pos, face); + ctmData.put(face, ctm); + } + } + + protected CTM createCTM() { + return CTM.getInstance(); + } + + public CTM getCTM(EnumFacing face) { + return ctmData.get(face); + } +} diff --git a/src/main/java/mekanism/client/render/ctm/ChiselFace.java b/src/main/java/mekanism/client/render/ctm/ChiselFace.java new file mode 100644 index 000000000..e887add0d --- /dev/null +++ b/src/main/java/mekanism/client/render/ctm/ChiselFace.java @@ -0,0 +1,85 @@ +package mekanism.client.render.ctm; + +import java.util.ArrayList; +import java.util.List; + +import net.minecraft.client.renderer.texture.TextureAtlasSprite; +import net.minecraft.util.EnumWorldBlockLayer; +import net.minecraft.util.ResourceLocation; + +/** + * Chisel Face, basically a list of IChiselTexture's + */ +public final class ChiselFace { + + private List textureList; + + private List childFaces; + + private ResourceLocation location; + + private EnumWorldBlockLayer layer; + + public ChiselFace(ResourceLocation location) { + this(new ArrayList<>(), new ArrayList<>(), location); + } + + public ChiselFace(ResourceLocation location, EnumWorldBlockLayer layer) { + this(location); + setLayer(layer); + } + + public ChiselFace(List textureList, List childFaces, ResourceLocation location) { + this.textureList = textureList; + this.childFaces = childFaces; + this.location = location; + } + + public List getTextureList(){ + List list = new ArrayList<>(); + list.addAll(this.textureList); + for (ChiselFace face : childFaces){ + list.addAll(face.getTextureList()); + } + return list; + } + + public void addTexture(ChiselTextureCTM texture){ + this.textureList.add(texture); + } + + public void addChildFace(ChiselFace face){ + this.childFaces.add(face); + } + + public boolean removeTexture(ChiselTextureCTM texture){ + return this.textureList.remove(texture); + } + + public boolean removeChildFace(ChiselFace face){ + return this.childFaces.remove(face); + } + + public TextureAtlasSprite getParticle(){ + if (textureList.get(0) != null) { + return textureList.get(0).getParticle(); + } + else { + return childFaces.get(0).getParticle(); + } + } + + public ResourceLocation getLocation(){ + return this.location; + } + + + public void setLayer(EnumWorldBlockLayer layer){ + this.layer = layer; + } + + public EnumWorldBlockLayer getLayer(){ + return this.layer; + } + +} diff --git a/src/main/java/mekanism/client/render/ctm/ChiselTextureCTM.java b/src/main/java/mekanism/client/render/ctm/ChiselTextureCTM.java new file mode 100644 index 000000000..2b0893353 --- /dev/null +++ b/src/main/java/mekanism/client/render/ctm/ChiselTextureCTM.java @@ -0,0 +1,59 @@ +package mekanism.client.render.ctm; + +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.List; +import java.util.Objects; +import java.util.stream.Collectors; + +import lombok.Getter; +import net.minecraft.client.renderer.block.model.BakedQuad; +import net.minecraft.client.renderer.texture.TextureAtlasSprite; +import net.minecraft.client.renderer.vertex.DefaultVertexFormats; +import net.minecraft.util.EnumWorldBlockLayer; +import net.minecraft.util.ResourceLocation; + +public class ChiselTextureCTM { + + @Getter + protected BlockRenderTypeCTM type; + @Getter + protected EnumWorldBlockLayer layer; + + protected TextureSpriteCallback[] sprites; + + public ChiselTextureCTM(BlockRenderTypeCTM type, EnumWorldBlockLayer layer, TextureSpriteCallback[] sprites) { + this.type = type; + this.layer = layer; + this.sprites = sprites; + } + + public List transformQuad(BakedQuad bq, CTMBlockRenderContext context, int quadGoal) { + Quad quad = Quad.from(bq, DefaultVertexFormats.ITEM); + if (context == null) { + return Collections.singletonList(quad.transformUVs(sprites[0].getSprite()).rebake()); + } + + Quad[] quads = quad.subdivide(4); + + int[] ctm = ((CTMBlockRenderContext)context).getCTM(bq.getFace()).getSubmapIndices(); + + for (int i = 0; i < quads.length; i++) { + Quad q = quads[i]; + if (q != null) { + int ctmid = q.getUvs().normalize().getQuadrant(); + quads[i] = q.grow().transformUVs(sprites[ctm[ctmid] > 15 ? 0 : 1].getSprite(), CTM.uvs[ctm[ctmid]].normalize()); + } + } + return Arrays.stream(quads).filter(Objects::nonNull).map(q -> q.rebake()).collect(Collectors.toList()); + } + + public TextureAtlasSprite getParticle(){ + return sprites[0].getSprite(); + } + + public Collection getTextures() { + return Arrays.stream(sprites).map(TextureSpriteCallback::getLocation).collect(Collectors.toList()); + } +} diff --git a/src/main/java/mekanism/client/render/ctm/Dir.java b/src/main/java/mekanism/client/render/ctm/Dir.java new file mode 100644 index 000000000..fa28018ba --- /dev/null +++ b/src/main/java/mekanism/client/render/ctm/Dir.java @@ -0,0 +1,186 @@ +package mekanism.client.render.ctm; + +import static net.minecraft.util.EnumFacing.DOWN; +import static net.minecraft.util.EnumFacing.EAST; +import static net.minecraft.util.EnumFacing.NORTH; +import static net.minecraft.util.EnumFacing.SOUTH; +import static net.minecraft.util.EnumFacing.UP; +import static net.minecraft.util.EnumFacing.WEST; +import net.minecraft.block.state.IBlockState; +import net.minecraft.util.BlockPos; +import net.minecraft.util.EnumFacing; +import net.minecraft.util.EnumFacing.Axis; +import net.minecraft.util.EnumFacing.AxisDirection; +import net.minecraft.world.IBlockAccess; +import mekanism.client.render.ctm.CTM; + +/** + * Think of this class as a "Two dimensional ForgeDirection, with diagonals". + *

+ * It represents the eight different directions a face of a block can connect with CTM, and contains the logic for determining if a block is indeed connected in that direction. + *

+ * Note that, for example, {@link #TOP_RIGHT} does not mean connected to the {@link #TOP} and {@link #RIGHT}, but connected in the diagonal direction represented by {@link #TOP_RIGHT}. This is used + * for inner corner rendering. + */ +public enum Dir { + // @formatter:off + TOP(UP), + TOP_RIGHT(UP, EAST), + RIGHT(EAST), + BOTTOM_RIGHT(DOWN, EAST), + BOTTOM(DOWN), + BOTTOM_LEFT(DOWN, WEST), + LEFT(WEST), + TOP_LEFT(UP, WEST); + // @formatter:on + + /** + * All values of this enum, used to prevent unnecessary allocation via {@link #values()}. + */ + public static final Dir[] VALUES = values(); + private static final EnumFacing NORMAL = SOUTH; + + private EnumFacing[] dirs; + + private Dir(EnumFacing... dirs) { + this.dirs = dirs; + } + + /** + * Finds if this block is connected for the given side in this Dir. + * + * @param inst + * The CTM instance to use for logic. + * @param world + * The world the block is in. + * @param pos + * The position of your block. + * @param side + * The side of the current face. + * @return True if the block is connected in the given Dir, false otherwise. + */ + public boolean isConnected(CTM ctm, IBlockAccess world, BlockPos pos, EnumFacing side) { + return ctm.isConnected(world, pos, getConnection(pos, side), side); + } + + /** + * Finds if this block is connected for the given side in this Dir. + * + * @param inst + * The CTM instance to use for logic. + * @param world + * The world the block is in. + * @param pos + * The position of your block. + * @param side + * The side of the current face. + * @param side + * The state to check for connection with. + * @return True if the block is connected in the given Dir, false otherwise. + */ + public boolean isConnected(CTM ctm, IBlockAccess world, BlockPos pos, EnumFacing side, IBlockState state) { + return ctm.isConnected(world, pos, getConnection(pos, side), side, state); + } + + private BlockPos getConnection(BlockPos pos, EnumFacing side) { + EnumFacing[] dirs = getNormalizedDirs(side); + BlockPos connection = pos; + for (EnumFacing dir : dirs) { + connection = connection.offset(dir); + } + return connection; + } + + private EnumFacing[] getNormalizedDirs(EnumFacing normal) { + if (normal == NORMAL) { + return dirs; + } else if (normal == NORMAL.getOpposite()) { + // If this is the opposite direction of the default normal, we + // need to mirror the dirs + // A mirror version does not affect y+ and y- so we ignore those + EnumFacing[] ret = new EnumFacing[dirs.length]; + for (int i = 0; i < ret.length; i++) { + ret[i] = dirs[i].getFrontOffsetY() != 0 ? dirs[i] : dirs[i].getOpposite(); + } + return ret; + } else { + EnumFacing axis = null; + // Next, we need different a different rotation axis depending + // on if this is up/down or not + if (normal.getFrontOffsetY() == 0) { + // If it is not up/down, pick either the left or right-hand + // rotation + axis = normal == NORMAL.rotateY() ? UP : DOWN; + } else { + // If it is up/down, pick either the up or down rotation. + axis = normal == UP ? NORMAL.rotateYCCW() : NORMAL.rotateY(); + } + EnumFacing[] ret = new EnumFacing[dirs.length]; + // Finally apply all the rotations + for (int i = 0; i < ret.length; i++) { + ret[i] = rotate(dirs[i], axis); + } + return ret; + } + } + + // God why + + private static final int[] FACING_LOOKUP = new int[EnumFacing.values().length]; + static { + FACING_LOOKUP[NORTH.ordinal()] = 1; + FACING_LOOKUP[EAST.ordinal()] = 2; + FACING_LOOKUP[SOUTH.ordinal()] = 3; + FACING_LOOKUP[WEST.ordinal()] = 4; + FACING_LOOKUP[UP.ordinal()] = 5; + FACING_LOOKUP[DOWN.ordinal()] = 6; + } + + private EnumFacing rotate(EnumFacing facing, EnumFacing axisFacing) { + Axis axis = axisFacing.getAxis(); + AxisDirection axisDir = axisFacing.getAxisDirection(); + + if (axisDir == AxisDirection.POSITIVE) { + return facing.rotateAround(axis); + } + + if (facing.getAxis() != axis) { + switch (axis) { + case X: + // I did some manual testing and this is what worked...I don't get it either + switch (FACING_LOOKUP[facing.ordinal()]) { + case 1: + return NORTH; + case 2: + case 4: + default: + return facing; // Invalid but ignored + case 3: + return SOUTH; + case 5: + return SOUTH; + case 6: + return NORTH; + } + case Y: + return facing.rotateYCCW(); + case Z: + switch (FACING_LOOKUP[facing.ordinal()]) { + case 2: + return EAST; + case 3: + default: + return facing; // invalid but ignored + case 4: + return WEST; + case 5: + return DOWN; + case 6: + return UP; + } + } + } + + return facing; + } +} \ No newline at end of file diff --git a/src/main/java/mekanism/client/render/ctm/ICTMBlock.java b/src/main/java/mekanism/client/render/ctm/ICTMBlock.java new file mode 100644 index 000000000..9c5d23fc0 --- /dev/null +++ b/src/main/java/mekanism/client/render/ctm/ICTMBlock.java @@ -0,0 +1,5 @@ +package mekanism.client.render.ctm; + +public interface ICTMBlock { + +} diff --git a/src/main/java/mekanism/client/render/ctm/ISubmap.java b/src/main/java/mekanism/client/render/ctm/ISubmap.java new file mode 100644 index 000000000..f0d91d8b0 --- /dev/null +++ b/src/main/java/mekanism/client/render/ctm/ISubmap.java @@ -0,0 +1,24 @@ +package mekanism.client.render.ctm; + +import net.minecraft.client.renderer.texture.TextureAtlasSprite; + +public interface ISubmap { + + float getYOffset(); + + float getXOffset(); + + float getWidth(); + + float getHeight(); + + float getInterpolatedU(TextureAtlasSprite sprite, float u); + + float getInterpolatedV(TextureAtlasSprite sprite, float v); + + float[] toArray(); + + ISubmap normalize(); + + ISubmap relativize(); +} diff --git a/src/main/java/mekanism/client/render/ctm/ModelCTM.java b/src/main/java/mekanism/client/render/ctm/ModelCTM.java new file mode 100644 index 000000000..f71de198b --- /dev/null +++ b/src/main/java/mekanism/client/render/ctm/ModelCTM.java @@ -0,0 +1,143 @@ +//package team.chisel.client.render.ctm; +// +//import team.chisel.common.block.BlockCarvable; +//import team.chisel.common.block.subblocks.ICTMSubBlock; +//import team.chisel.common.block.subblocks.ISubBlock; +//import team.chisel.common.connections.CTMConnections; +//import team.chisel.common.util.EnumConnection; +//import team.chisel.common.util.SubBlockUtil; +//import team.chisel.common.variation.PropertyVariation; +//import team.chisel.common.variation.Variation; +//import net.minecraft.block.state.IBlockState; +//import net.minecraft.client.renderer.block.model.BakedQuad; +//import net.minecraft.client.renderer.block.model.ItemCameraTransforms; +//import net.minecraft.client.renderer.texture.TextureAtlasSprite; +//import net.minecraft.client.resources.model.IBakedModel; +//import net.minecraft.util.EnumFacing; +//import net.minecraftforge.client.model.ISmartBlockModel; +//import net.minecraftforge.common.property.IExtendedBlockState; +// +//import javax.vecmath.Vector3f; +//import java.util.ArrayList; +//import java.util.List; +// +///** +// * Block Model for Connected textures +// * Deals with the Connected texture rendering basically +// * +// * @author minecreatr +// */ +//public class ModelCTM implements ISmartBlockModel { +// +// +// private List quads; +// +// private TextureAtlasSprite particle; +// +// +// @Override +// public List getFaceQuads(EnumFacing face) { +// List toReturn = new ArrayList(); +// for (BakedQuad quad : quads) { +// if (quad == null) { +// continue; +// } +// if (quad.getFace() == face) { +// toReturn.add(quad); +// } +// } +// return toReturn; +// } +// +// @Override +// public List getGeneralQuads() { +// return this.quads; +// } +// +// @Override +// public boolean isAmbientOcclusion() { +// return true; +// } +// +// @Override +// public boolean isGui3d() { +// return true; +// } +// +// @Override +// public boolean isBuiltInRenderer() { +// return false; +// } +// +// @Override +// public TextureAtlasSprite getTexture() { +// return particle; +// } +// +// @Override +// public ItemCameraTransforms getItemCameraTransforms() { +// return ItemCameraTransforms.DEFAULT; +// } +// +// @Override +// public IBakedModel handleBlockState(IBlockState state) { +// // /throw new RuntimeException(state.getValue(BlockCarvable.VARIATION).toString()); +// PropertyVariation VARIATION = null; +// if (state.getBlock() instanceof BlockCarvable) { +// VARIATION = ((BlockCarvable) state.getBlock()).variation; +// } +// List newQuads = generateQuads(state, VARIATION); +// this.quads = newQuads; +// this.particle = SubBlockUtil.getResources(state.getBlock(), (Variation) state.getValue(VARIATION)).getDefaultTexture(); +// return this; +// } +// +// private List generateQuads(IBlockState state, PropertyVariation VARIATION) { +// List newQuads = new ArrayList(); +// Variation variation = (Variation) state.getValue(VARIATION); +// if (state.getBlock() instanceof BlockCarvable) { +// ISubBlock subBlock = ((BlockCarvable) state.getBlock()).getSubBlock(variation); +// if (subBlock instanceof ICTMSubBlock) { +// ICTMSubBlock ctmSubBlock = (ICTMSubBlock) subBlock; +// for (EnumFacing f : EnumFacing.values()) { +// if (!isTouchingSide(state, f)) { +// CTMFaceBakery.instance.makeCtmFace(f, ctmSubBlock.getResources(), CTM.getInstance().getSubmapIndices((IExtendedBlockState) state, f)).addToList(newQuads); +// } +// } +// } +// } +// return newQuads; +// } +// +// public static boolean isTouchingSide(IBlockState inState, EnumFacing f) { +// if (inState == null) { +// return false; +// } +// if (!(inState instanceof IExtendedBlockState)) { +// return false; +// } +// IExtendedBlockState state = (IExtendedBlockState) inState; +// CTMConnections connections = state.getValue(BlockCarvable.CONNECTIONS); +// if (connections.isConnected(EnumConnection.UP) && f == EnumFacing.UP) { +// return true; +// } +// if (connections.isConnected(EnumConnection.DOWN) && f == EnumFacing.DOWN) { +// return true; +// } +// if (connections.isConnected(EnumConnection.NORTH) && f == EnumFacing.NORTH) { +// return true; +// } +// if (connections.isConnected(EnumConnection.SOUTH) && f == EnumFacing.SOUTH) { +// return true; +// } +// if (connections.isConnected(EnumConnection.WEST) && f == EnumFacing.WEST) { +// return true; +// } +// if (connections.isConnected(EnumConnection.EAST) && f == EnumFacing.EAST) { +// return true; +// } +// return false; +// } +// +// +//} diff --git a/src/main/java/mekanism/client/render/ctm/ModelChisel.java b/src/main/java/mekanism/client/render/ctm/ModelChisel.java new file mode 100644 index 000000000..5e45cebbb --- /dev/null +++ b/src/main/java/mekanism/client/render/ctm/ModelChisel.java @@ -0,0 +1,107 @@ +package mekanism.client.render.ctm; + +import java.util.Collection; +import java.util.EnumMap; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; +import java.util.stream.Collectors; + +import lombok.SneakyThrows; +import net.minecraft.block.state.IBlockState; +import net.minecraft.client.Minecraft; +import net.minecraft.client.renderer.block.model.ModelBlockDefinition.Variant; +import net.minecraft.client.renderer.block.statemap.DefaultStateMapper; +import net.minecraft.client.renderer.block.statemap.StateMapperBase; +import net.minecraft.client.renderer.texture.TextureAtlasSprite; +import net.minecraft.client.renderer.texture.TextureMap; +import net.minecraft.client.renderer.vertex.VertexFormat; +import net.minecraft.client.resources.model.IBakedModel; +import net.minecraft.util.EnumFacing; +import net.minecraft.util.ResourceLocation; +import net.minecraftforge.client.model.IFlexibleBakedModel; +import net.minecraftforge.client.model.IModel; +import net.minecraftforge.client.model.IModelState; +import net.minecraftforge.client.model.ModelLoader; +import net.minecraftforge.client.model.ModelLoaderRegistry; +import net.minecraftforge.client.model.TRSRTransformation; +import net.minecraftforge.common.property.IExtendedBlockState; + +import com.google.common.base.Function; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.Lists; +import com.google.common.collect.Maps; + + +public class ModelChisel implements IModel { + + private static StateMapperBase mapper = new DefaultStateMapper(); + + private Variant model; + private Map models = Maps.newHashMap();; + + private String face; + private Map overrides = Maps.newHashMap(); + + private transient ChiselFace faceObj; + private transient Map overridesObj = new EnumMap<>(EnumFacing.class); + private transient IBakedModel modelObj; + + private transient Map modelsObj = Maps.newHashMap(); + + private transient Map stateMap = Maps.newHashMap(); + + private transient List textures = Lists.newArrayList(); + + @Override + public Collection getDependencies() { + List list = Lists.newArrayList(model.getModelLocation()); + list.addAll(models.values().stream().map(v -> v.getModelLocation()).collect(Collectors.toList())); + return list; + } + + @Override + public Collection getTextures() { + return ImmutableList.copyOf(textures); + } + + @Override + @SneakyThrows + public IFlexibleBakedModel bake(IModelState state, VertexFormat format, Function bakedTextureGetter) { + Function dummyGetter = t -> Minecraft.getMinecraft().getTextureMapBlocks().getAtlasSprite(TextureMap.LOCATION_MISSING_TEXTURE.toString()); + modelObj = ModelLoaderRegistry.getModel(model.getModelLocation()).bake(model.isUvLocked() ? new ModelLoader.UVLock(model.getState()) : model.getState(), format, dummyGetter); + for (Entry e : models.entrySet()) { + Variant v = e.getValue(); + modelsObj.put(e.getKey(), ModelLoaderRegistry.getModel(v.getModelLocation()).bake(v.isUvLocked() ? new ModelLoader.UVLock(v.getState()) : v.getState(), format, dummyGetter)); + } + return new ModelChiselBlock(this); + } + + @Override + public IModelState getDefaultState() { + return TRSRTransformation.identity(); + } + + public ChiselFace getDefaultFace() { + return faceObj; + } + + public ChiselFace getFace(EnumFacing facing) { + return overridesObj.getOrDefault(facing, faceObj); + } + + public IBakedModel getModel(IBlockState state) { + if (state instanceof IExtendedBlockState) { + state = ((IExtendedBlockState)state).getClean(); + } + String stateStr = mapper.getPropertyString(state.getProperties()); + stateStr = stateStr.substring(stateStr.indexOf(",") + 1, stateStr.length()); + + final String capture = stateStr; + if (modelsObj.containsKey(stateStr)) { + stateMap.computeIfAbsent(state, s -> modelsObj.get(capture)); + } + + return stateMap.getOrDefault(state, modelObj); + } +} diff --git a/src/main/java/mekanism/client/render/ctm/ModelChiselBlock.java b/src/main/java/mekanism/client/render/ctm/ModelChiselBlock.java new file mode 100644 index 000000000..c7efbdfad --- /dev/null +++ b/src/main/java/mekanism/client/render/ctm/ModelChiselBlock.java @@ -0,0 +1,156 @@ +package mekanism.client.render.ctm; + +import java.util.Collections; +import java.util.List; + +import javax.annotation.Nullable; +import javax.vecmath.Matrix4f; +import javax.vecmath.Vector3f; + +import mekanism.common.block.BlockBasic; +import net.minecraft.block.Block; +import net.minecraft.block.state.IBlockState; +import net.minecraft.client.renderer.block.model.BakedQuad; +import net.minecraft.client.renderer.block.model.ItemCameraTransforms; +import net.minecraft.client.renderer.block.model.ItemCameraTransforms.TransformType; +import net.minecraft.client.renderer.texture.TextureAtlasSprite; +import net.minecraft.client.renderer.vertex.VertexFormat; +import net.minecraft.client.resources.model.IBakedModel; +import net.minecraft.item.ItemBlock; +import net.minecraft.item.ItemStack; +import net.minecraft.util.EnumFacing; +import net.minecraftforge.client.model.Attributes; +import net.minecraftforge.client.model.IFlexibleBakedModel; +import net.minecraftforge.client.model.IPerspectiveAwareModel; +import net.minecraftforge.client.model.ISmartBlockModel; +import net.minecraftforge.client.model.ISmartItemModel; +import net.minecraftforge.client.model.TRSRTransformation; +import net.minecraftforge.common.property.IExtendedBlockState; + +import org.apache.commons.lang3.tuple.ImmutablePair; +import org.apache.commons.lang3.tuple.Pair; + +import com.google.common.collect.FluentIterable; +import com.google.common.collect.Lists; +import com.google.common.collect.Ordering; + +/** + * Model for all chisel blocks + */ +@SuppressWarnings("deprecation") +public class ModelChiselBlock implements ISmartBlockModel, ISmartItemModel, IPerspectiveAwareModel { + + public static final TRSRTransformation DEFAULT_BLOCK_THIRD_PERSON_TRANSOFRM = new TRSRTransformation(new Vector3f(0, 1.5f / 16f, -2.75f / 16f), TRSRTransformation.quatFromYXZDegrees(new Vector3f(10, -45, 170)), new Vector3f(0.375f, 0.375f, 0.375f), null); + public static final Matrix4f DEFAULT_BLOCK_THIRD_PERSON_MATRIX = DEFAULT_BLOCK_THIRD_PERSON_TRANSOFRM.getMatrix(); + + private List face; + private List general; + + private ModelChisel model; + + public ModelChiselBlock(List face, List general, ModelChisel model){ + this.face = face; + this.general = general; + this.model = model; + } + + public ModelChiselBlock(ModelChisel model){ + this(Collections.emptyList(), Collections.emptyList(), model); + } + + @Override + public List getFaceQuads(EnumFacing facing){ + return FluentIterable.from(face).filter(quad -> quad.getFace() == facing).toList(); + } + + @Override + public List getGeneralQuads() { + return general; + } + + @Override + public boolean isAmbientOcclusion(){ + return true; + } + + @Override + public boolean isGui3d(){ + return true; + } + + @Override + public boolean isBuiltInRenderer(){ + return false; + } + + @Override + public TextureAtlasSprite getParticleTexture() { + return this.model.getDefaultFace().getParticle(); + } + + @Override + public ItemCameraTransforms getItemCameraTransforms(){ + return ItemCameraTransforms.DEFAULT; + } + + // TODO implement model caching, returning a new model every time is a HUGE waste of memory and CPU + + @Override + public IBakedModel handleBlockState(IBlockState stateIn) { + if (stateIn.getBlock() instanceof ICTMBlock && stateIn instanceof IExtendedBlockState) { + IExtendedBlockState state = (IExtendedBlockState) stateIn; + CTMBlockRenderContext ctxList = state.getValue(BlockBasic.ctmProperty); + return createModel(stateIn, model, ctxList); + } else { + return this; + } + } + + @Override + public IBakedModel handleItemState(ItemStack stack) { + Block block = ((ItemBlock) stack.getItem()).getBlock(); + return createModel(block.getDefaultState(), model, null); + } + + private ModelChiselBlock createModel(IBlockState state, ModelChisel model, CTMBlockRenderContext ctx) { + List faceQuads = Lists.newArrayList(); + List generalQuads = Lists.newArrayList(); + for (EnumFacing facing : EnumFacing.VALUES){ + ChiselFace face = model.getFace(facing); + + int quadGoal = ctx == null ? 1 : Ordering.natural().max(FluentIterable.from(face.getTextureList()).transform(tex -> tex.getType().getQuadsPerSide())); + IBakedModel baked = model.getModel(state); + List origFaceQuads = baked.getFaceQuads(facing); + List origGeneralQuads = FluentIterable.from(baked.getGeneralQuads()).filter(q -> q.getFace() == facing).toList(); + addAllQuads(origFaceQuads, face, ctx, quadGoal, faceQuads); + addAllQuads(origGeneralQuads, face, ctx, quadGoal, generalQuads); + } + return new ModelChiselBlock(faceQuads, generalQuads, model); + } + + private void addAllQuads(List from, ChiselFace face, @Nullable CTMBlockRenderContext ctx, int quadGoal, List to) { + for (BakedQuad q : from) { + for (ChiselTextureCTM tex : face.getTextureList()) { + to.addAll(tex.transformQuad(q, ctx == null ? null : ctx, quadGoal)); + } + } + } + + @Override + public VertexFormat getFormat() { + return Attributes.DEFAULT_BAKED_FORMAT; + } + + private Pair thirdPersonTransform; + + @Override + public Pair handlePerspective(ItemCameraTransforms.TransformType cameraTransformType) { + if (cameraTransformType == TransformType.THIRD_PERSON) { + if (thirdPersonTransform == null) { + thirdPersonTransform = ImmutablePair.of(this, DEFAULT_BLOCK_THIRD_PERSON_MATRIX); + } + return thirdPersonTransform; + } + return Pair.of(this, null); + } +} diff --git a/src/main/java/mekanism/client/render/ctm/PropertyCTMRenderContext.java b/src/main/java/mekanism/client/render/ctm/PropertyCTMRenderContext.java new file mode 100644 index 000000000..8759cb566 --- /dev/null +++ b/src/main/java/mekanism/client/render/ctm/PropertyCTMRenderContext.java @@ -0,0 +1,29 @@ +package mekanism.client.render.ctm; + +import net.minecraftforge.common.property.IUnlistedProperty; + +/** + * Block Property for the render context list + */ +public class PropertyCTMRenderContext implements IUnlistedProperty { + + @Override + public String getName(){ + return "connections"; + } + + @Override + public boolean isValid(CTMBlockRenderContext value){ + return true; + } + + @Override + public Class getType(){ + return CTMBlockRenderContext.class; + } + + @Override + public String valueToString(CTMBlockRenderContext value){ + return value.toString(); + } +} diff --git a/src/main/java/mekanism/client/render/ctm/Quad.java b/src/main/java/mekanism/client/render/ctm/Quad.java new file mode 100644 index 000000000..379d479c7 --- /dev/null +++ b/src/main/java/mekanism/client/render/ctm/Quad.java @@ -0,0 +1,439 @@ +package mekanism.client.render.ctm; + +import java.util.List; + +import javax.annotation.Nullable; + +import lombok.Getter; +import lombok.RequiredArgsConstructor; +import lombok.Setter; +import lombok.ToString; +import lombok.Value; +import net.minecraft.client.Minecraft; +import net.minecraft.client.renderer.block.model.BakedQuad; +import net.minecraft.client.renderer.texture.TextureAtlasSprite; +import net.minecraft.client.renderer.texture.TextureMap; +import net.minecraft.client.renderer.vertex.VertexFormat; +import net.minecraft.client.renderer.vertex.VertexFormatElement; +import net.minecraft.client.renderer.vertex.VertexFormatElement.EnumUsage; +import net.minecraft.util.EnumFacing; +import net.minecraftforge.client.model.pipeline.IVertexConsumer; +import net.minecraftforge.client.model.pipeline.UnpackedBakedQuad; + +import org.apache.commons.lang3.tuple.Pair; +import org.lwjgl.util.vector.Vector; +import org.lwjgl.util.vector.Vector2f; +import org.lwjgl.util.vector.Vector3f; + +import com.google.common.collect.ListMultimap; +import com.google.common.collect.Lists; +import com.google.common.collect.MultimapBuilder; + +@ToString(of = { "vertPos", "vertUv" }) +public class Quad { + + public static final ISubmap TOP_LEFT = new Submap(8, 8, 0, 0); + public static final ISubmap TOP_RIGHT = new Submap(8, 8, 8, 0); + public static final ISubmap BOTTOM_LEFT = new Submap(8, 8, 0, 8); + public static final ISubmap BOTTOM_RIGHT = new Submap(8, 8, 8, 8); + + @Value + public static class Vertex { + Vector3f pos; + Vector2f uvs; + } + + private static final TextureAtlasSprite BASE = Minecraft.getMinecraft().getTextureMapBlocks().getAtlasSprite(TextureMap.LOCATION_MISSING_TEXTURE.toString()); + + @ToString + public class UVs { + + @Getter + private float minU, minV, maxU, maxV; + + @Getter + private final TextureAtlasSprite sprite; + + private final Vector2f[] data; + + private UVs(Vector2f... data) { + this(BASE, data); + } + + private UVs(TextureAtlasSprite sprite, Vector2f... data) { + this.data = data; + this.sprite = sprite; + + float minU = Float.MAX_VALUE; + float minV = Float.MAX_VALUE; + float maxU = 0, maxV = 0; + for (Vector2f v : data) { + minU = Math.min(minU, v.x); + minV = Math.min(minV, v.y); + maxU = Math.max(maxU, v.x); + maxV = Math.max(maxV, v.y); + } + this.minU = minU; + this.minV = minV; + this.maxU = maxU; + this.maxV = maxV; + } + + public UVs(float minU, float minV, float maxU, float maxV, TextureAtlasSprite sprite) { + this.minU = minU; + this.minV = minV; + this.maxU = maxU; + this.maxV = maxV; + this.sprite = sprite; + this.data = vectorize(); + } + + public UVs transform(TextureAtlasSprite other, ISubmap submap) { + UVs normal = normalize(); + submap = submap.normalize(); + + float width = normal.maxU - normal.minU; + float height = normal.maxV - normal.minV; + + float minU = submap.getXOffset(); + float minV = submap.getYOffset(); + minU += normal.minU * submap.getWidth(); + minV += normal.minV * submap.getHeight(); + + float maxU = minU + (width * submap.getWidth()); + float maxV = minV + (height * submap.getHeight()); + + // TODO this is horrid + return new UVs(other, + new Vector2f(data[0].x == this.minU ? minU : maxU, data[0].y == this.minV ? minV : maxV), + new Vector2f(data[1].x == this.minU ? minU : maxU, data[1].y == this.minV ? minV : maxV), + new Vector2f(data[2].x == this.minU ? minU : maxU, data[2].y == this.minV ? minV : maxV), + new Vector2f(data[3].x == this.minU ? minU : maxU, data[3].y == this.minV ? minV : maxV)) + .relativize(); + } + + UVs normalizeQuadrant() { + UVs normal = normalize(); + + int quadrant = normal.getQuadrant(); + float minUInterp = quadrant == 1 || quadrant == 2 ? 0.5f : 0; + float minVInterp = quadrant < 2 ? 0.5f : 0; + float maxUInterp = quadrant == 0 || quadrant == 3 ? 0.5f : 1; + float maxVInterp = quadrant > 1 ? 0.5f : 1; + + normal = new UVs(sprite, normalize(new Vector2f(minUInterp, minVInterp), new Vector2f(maxUInterp, maxVInterp), normal.vectorize())); + return normal.relativize(); + } + + public UVs normalize() { + Vector2f min = new Vector2f(sprite.getMinU(), sprite.getMinV()); + Vector2f max = new Vector2f(sprite.getMaxU(), sprite.getMaxV()); + return new UVs(sprite, normalize(min, max, data)); + } + + public UVs relativize() { + return relativize(sprite); + } + + public UVs relativize(TextureAtlasSprite sprite) { + Vector2f min = new Vector2f(sprite.getMinU(), sprite.getMinV()); + Vector2f max = new Vector2f(sprite.getMaxU(), sprite.getMaxV()); + return new UVs(sprite, lerp(min, max, data)); + } + + public Vector2f[] vectorize() { + return data == null ? new Vector2f[]{ new Vector2f(minU, minV), new Vector2f(minU, maxV), new Vector2f(maxU, maxV), new Vector2f(maxU, minV) } : data; + } + + private Vector2f[] normalize(Vector2f min, Vector2f max, Vector2f... vecs) { + Vector2f[] ret = new Vector2f[vecs.length]; + for (int i = 0; i < ret.length; i++) { + ret[i] = normalize(min, max, vecs[i]); + } + return ret; + } + + private Vector2f normalize(Vector2f min, Vector2f max, Vector2f vec) { + return new Vector2f(Quad.normalize(min.x, max.x, vec.x), Quad.normalize(min.y, max.y, vec.y)); + } + + private Vector2f[] lerp(Vector2f min, Vector2f max, Vector2f... vecs) { + Vector2f[] ret = new Vector2f[vecs.length]; + for (int i = 0; i < ret.length; i++) { + ret[i] = lerp(min, max, vecs[i]); + } + return ret; + } + + private Vector2f lerp(Vector2f min, Vector2f max, Vector2f vec) { + return new Vector2f(Quad.lerp(min.x, max.x, vec.x), Quad.lerp(min.y, max.y, vec.y)); + } + + public int getQuadrant() { + if (maxU <= 0.5f) { + if (maxV <= 0.5f) { + return 3; + } else { + return 0; + } + } else { + if (maxV <= 0.5f) { + return 2; + } else { + return 1; + } + } + } + } + + private final Vector3f[] vertPos; + private final Vector2f[] vertUv; + + // Technically nonfinal, but treated as such except in constructor + @Getter + private UVs uvs; + + private final Builder builder; + + private Quad(Vector3f[] verts, Vector2f[] uvs, Builder builder) { + this.vertPos = verts; + this.vertUv = uvs; + this.builder = builder; + this.uvs = new UVs(uvs); + } + + private Quad(Vector3f[] verts, UVs uvs, Builder builder) { + this(verts, uvs.vectorize(), builder); + this.uvs = new UVs(uvs.getSprite(), vertUv); + } + + public void compute() { + + } + + public Quad[] subdivide(int count) { + List rects = Lists.newArrayList(); + + Pair firstDivide = divide(false); + Pair secondDivide = firstDivide.getLeft().divide(true); + rects.add(secondDivide.getLeft()); + + if (firstDivide.getRight() != null) { + Pair thirdDivide = firstDivide.getRight().divide(true); + rects.add(thirdDivide.getLeft()); + rects.add(thirdDivide.getRight()); + } else { + rects.add(null); + rects.add(null); + } + + rects.add(secondDivide.getRight()); + + return rects.toArray(new Quad[rects.size()]); + } + + @Nullable + private Pair divide(boolean vertical) { + float min, max; + UVs uvs = getUvs().normalize(); + if (vertical) { + min = uvs.minV; + max = uvs.maxV; + } else { + min = uvs.minU; + max = uvs.maxU; + } + if (min < 0.5 && max > 0.5) { + UVs first = new UVs(vertical ? uvs.minU : 0.5f, vertical ? 0.5f : uvs.minV, uvs.maxU, uvs.maxV, uvs.getSprite()); + UVs second = new UVs(uvs.minU, uvs.minV, vertical ? uvs.maxU : 0.5f, vertical ? 0.5f : uvs.maxV, uvs.getSprite()); + + int firstIndex = 0; + for (int i = 0; i < vertUv.length; i++) { + if (vertUv[i].y == getUvs().minV && vertUv[i].x == getUvs().minU) { + firstIndex = i; + break; + } + } + + float f = (0.5f - min) / (max - min); + + Vector3f[] firstQuad = new Vector3f[4]; + Vector3f[] secondQuad = new Vector3f[4]; + for (int i = 0; i < 4; i++) { + int idx = (firstIndex + i) % 4; + firstQuad[i] = new Vector3f(vertPos[idx]); + secondQuad[i] = new Vector3f(vertPos[idx]); + } + + int i1 = 0; + int i2 = vertical ? 1 : 3; + int j1 = vertical ? 3 : 1; + int j2 = 2; + + firstQuad[i1].x = lerp(firstQuad[i1].x, firstQuad[i2].x, f); + firstQuad[i1].y = lerp(firstQuad[i1].y, firstQuad[i2].y, f); + firstQuad[i1].z = lerp(firstQuad[i1].z, firstQuad[i2].z, f); + firstQuad[j1].x = lerp(firstQuad[j1].x, firstQuad[j2].x, f); + firstQuad[j1].y = lerp(firstQuad[j1].y, firstQuad[j2].y, f); + firstQuad[j1].z = lerp(firstQuad[j1].z, firstQuad[j2].z, f); + + secondQuad[i2].x = lerp(secondQuad[i1].x, secondQuad[i2].x, f); + secondQuad[i2].y = lerp(secondQuad[i1].y, secondQuad[i2].y, f); + secondQuad[i2].z = lerp(secondQuad[i1].z, secondQuad[i2].z, f); + secondQuad[j2].x = lerp(secondQuad[j1].x, secondQuad[j2].x, f); + secondQuad[j2].y = lerp(secondQuad[j1].y, secondQuad[j2].y, f); + secondQuad[j2].z = lerp(secondQuad[j1].z, secondQuad[j2].z, f); + + Quad q1 = new Quad(firstQuad, first.relativize(), builder); + Quad q2 = new Quad(secondQuad, second.relativize(), builder); + return Pair.of(q1, q2); + } else { + return Pair.of(this, null); + } + } + + static float lerp(float a, float b, float f) { + float ret = (a * (1 - f)) + (b * f); + return ret; + } + + static float normalize(float min, float max, float x) { + float ret = (x - min) / (max - min); + return ret; + } + + public Quad rotate(int amount) { + Vector2f[] uvs = new Vector2f[4]; + + TextureAtlasSprite s = getUvs().getSprite(); + + for (int i = 0; i < 4; i++) { + Vector2f normalized = new Vector2f(normalize(s.getMinU(), s.getMaxU(), vertUv[i].x), normalize(s.getMinV(), s.getMaxV(), vertUv[i].y)); + Vector2f uv; + switch (amount) { + case 1: + uv = new Vector2f(normalized.y, 1 - normalized.x); + break; + case 2: + uv = new Vector2f(1 - normalized.x, 1 - normalized.y); + break; + case 3: + uv = new Vector2f(1 - normalized.y, normalized.x); + break; + default: + uv = new Vector2f(normalized.x, normalized.y); + break; + } + uvs[i] = uv; + } + + for (int i = 0; i < uvs.length; i++) { + uvs[i] = new Vector2f(lerp(s.getMinU(), s.getMaxU(), uvs[i].x), lerp(s.getMinV(), s.getMaxV(), uvs[i].y)); + } + + Quad ret = new Quad(vertPos, uvs, builder); + ret.uvs = new UVs(getUvs().getSprite(), ret.vertUv); + return ret; + } + + public Quad derotate() { + int start = 0; + for (int i = 0; i < 4; i++) { + if (vertUv[i].x <= getUvs().minU && vertUv[i].y <= getUvs().minV) { + start = i; + break; + } + } + + Vector2f[] uvs = new Vector2f[4]; + for (int i = 0; i < 4; i++) { + uvs[i] = vertUv[(i + start) % 4]; + } + return new Quad(vertPos, uvs, builder); + } + + public BakedQuad rebake() { + UnpackedBakedQuad.Builder builder = new UnpackedBakedQuad.Builder(this.builder.vertexFormat); + builder.setQuadOrientation(this.builder.quadOrientation); + builder.setQuadTint(this.builder.quadTint); + + for (int v = 0; v < 4; v++) { + for (int i = 0; i < this.builder.vertexFormat.getElementCount(); i++) { + VertexFormatElement ele = this.builder.vertexFormat.getElement(i); + switch (ele.getUsage()) { + case UV: + Vector2f uv = vertUv[v]; + builder.put(i, uv.x, uv.y, 0, 1); + break; + case POSITION: + Vector3f p = vertPos[v]; + builder.put(i, p.x, p.y, p.z, 1); + break; + default: + builder.put(i, this.builder.data.get(ele.getUsage()).get(v)); + } + } + } + + return builder.build(); + } + + public Quad transformUVs(TextureAtlasSprite sprite) { + return transformUVs(sprite, CTM.FULL_TEXTURE.normalize()); + } + + public Quad transformUVs(TextureAtlasSprite sprite, ISubmap submap) { + return new Quad(vertPos, getUvs().transform(sprite, submap), builder); + } + + public Quad grow() { + return new Quad(vertPos, getUvs().normalizeQuadrant(), builder); + } + + public static Quad from(BakedQuad baked, VertexFormat fmt) { + Builder b = new Builder(fmt); + baked.pipe(b); + return b.build().derotate(); // for now we will ignore rotated UVs + } + + @RequiredArgsConstructor + public static class Builder implements IVertexConsumer { + + @Getter + private final VertexFormat vertexFormat; + + @Setter + private int quadTint; + + @Setter + private EnumFacing quadOrientation; + + @Override + public void setQuadColored() {} + + private ListMultimap data = MultimapBuilder.enumKeys(EnumUsage.class).arrayListValues().build(); + + @Override + public void put(int element, float... data) { + float[] copy = new float[data.length]; + System.arraycopy(data, 0, copy, 0, data.length); + VertexFormatElement ele = vertexFormat.getElement(element); + this.data.put(ele.getUsage(), copy); + } + + public Quad build() { + Vector3f[] verts = fromData(data.get(EnumUsage.POSITION), 3); + Vector2f[] uvs = fromData(data.get(EnumUsage.UV), 2); + return new Quad(verts, uvs, this); + } + + @SuppressWarnings("unchecked") + private T[] fromData(List data, int size) { + Vector[] ret = size == 2 ? new Vector2f[data.size()] : new Vector3f[data.size()]; + for (int i = 0; i < data.size(); i++) { + ret[i] = size == 2 ? new Vector2f(data.get(i)[0], data.get(i)[1]) : new Vector3f(data.get(i)[0], data.get(i)[1], data.get(i)[2]); + } + return (T[]) ret; + } + } +} diff --git a/src/main/java/mekanism/client/render/ctm/Submap.java b/src/main/java/mekanism/client/render/ctm/Submap.java new file mode 100644 index 000000000..e313001f1 --- /dev/null +++ b/src/main/java/mekanism/client/render/ctm/Submap.java @@ -0,0 +1,94 @@ +package mekanism.client.render.ctm; + +import lombok.AllArgsConstructor; +import lombok.Getter; +import lombok.RequiredArgsConstructor; +import net.minecraft.client.renderer.texture.TextureAtlasSprite; + +@Getter +@AllArgsConstructor +public class Submap implements ISubmap { + + private final float width, height; + private final float xOffset, yOffset; + + private final SubmapNormalized normalized = new SubmapNormalized(this); + + @Override + public float getInterpolatedU(TextureAtlasSprite sprite, float u) { + return sprite.getInterpolatedU(getXOffset() + u / getWidth()); + } + + @Override + public float getInterpolatedV(TextureAtlasSprite sprite, float v) { + return sprite.getInterpolatedV(getYOffset() + v / getWidth()); + } + + @Override + public float[] toArray() { + return new float[] { getXOffset(), getYOffset(), getXOffset() + getWidth(), getYOffset() + getHeight() }; + } + + @Override + public SubmapNormalized normalize() { + return normalized; + } + + @Override + public ISubmap relativize() { + return this; + } + + private static final float FACTOR = 16f; + + @RequiredArgsConstructor + private static class SubmapNormalized implements ISubmap { + + private final ISubmap parent; + + @Override + public float getXOffset() { + return parent.getXOffset() / FACTOR; + } + + @Override + public float getYOffset() { + return parent.getYOffset() / FACTOR; + } + + @Override + public float getWidth() { + return parent.getWidth() / FACTOR; + } + + @Override + public float getHeight() { + return parent.getHeight() / FACTOR; + } + + @Override + public ISubmap relativize() { + return parent; + } + + @Override + public ISubmap normalize() { + return this; + } + + @Override + public float getInterpolatedU(TextureAtlasSprite sprite, float u) { + return parent.getInterpolatedU(sprite, u); + } + + @Override + public float getInterpolatedV(TextureAtlasSprite sprite, float v) { + return parent.getInterpolatedV(sprite, v); + } + + @Override + public float[] toArray() { + return parent.toArray(); + } + } +} diff --git a/src/main/java/mekanism/client/render/ctm/TextureSpriteCallback.java b/src/main/java/mekanism/client/render/ctm/TextureSpriteCallback.java new file mode 100644 index 000000000..05860b3bf --- /dev/null +++ b/src/main/java/mekanism/client/render/ctm/TextureSpriteCallback.java @@ -0,0 +1,24 @@ +package mekanism.client.render.ctm; + +import lombok.Getter; +import net.minecraft.client.renderer.texture.TextureAtlasSprite; +import net.minecraft.client.renderer.texture.TextureMap; +import net.minecraft.util.ResourceLocation; + +/** + * Callback when textures are stitched + */ +@Getter +public class TextureSpriteCallback { + + private ResourceLocation location; + private TextureAtlasSprite sprite; + + public TextureSpriteCallback(ResourceLocation loc) { + this.location = loc; + } + + public void stitch(TextureMap map) { + this.sprite = map.registerSprite(location); + } +} diff --git a/src/main/java/mekanism/client/render/tileentity/RenderEnergyCube.java b/src/main/java/mekanism/client/render/tileentity/RenderEnergyCube.java index 9d26f0439..8fa4ccbf8 100644 --- a/src/main/java/mekanism/client/render/tileentity/RenderEnergyCube.java +++ b/src/main/java/mekanism/client/render/tileentity/RenderEnergyCube.java @@ -13,15 +13,13 @@ import mekanism.common.tile.TileEntityEnergyCube; import mekanism.common.util.MekanismUtils; import mekanism.common.util.MekanismUtils.ResourceType; import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer; -import net.minecraft.tileentity.TileEntity; import net.minecraft.util.EnumFacing; import net.minecraft.util.ResourceLocation; - -import org.lwjgl.opengl.GL11; - import net.minecraftforge.fml.relauncher.Side; import net.minecraftforge.fml.relauncher.SideOnly; +import org.lwjgl.opengl.GL11; + @SideOnly(Side.CLIENT) public class RenderEnergyCube extends TileEntitySpecialRenderer { @@ -48,7 +46,6 @@ public class RenderEnergyCube extends TileEntitySpecialRenderer openedThisTick = new HashSet(); diff --git a/src/main/resources/assets/mekanism/blockstates/chemical_injection_chamber.json b/src/main/resources/assets/mekanism/blockstates/chemical_injection_chamber.json index ca4713261..903bce853 100644 --- a/src/main/resources/assets/mekanism/blockstates/chemical_injection_chamber.json +++ b/src/main/resources/assets/mekanism/blockstates/chemical_injection_chamber.json @@ -8,7 +8,8 @@ "west": "mekanism:blocks/chemical_injection_chamber/ChemicalInjectionChamberRight", "east": "mekanism:blocks/chemical_injection_chamber/ChemicalInjectionChamberLeft", "south": "mekanism:blocks/chemical_injection_chamber/ChemicalInjectionChamberBack", - "up": "mekanism:blocks/chemical_injection_chamber/ChemicalInjectionChamberTop" + "up": "mekanism:blocks/chemical_injection_chamber/ChemicalInjectionChamberTop", + "down": "mekanism:blocks/chemical_injection_chamber/ChemicalInjectionChamberBottom" } }, "variants": { @@ -19,7 +20,15 @@ "west": {"y": -90} }, "active": { - "true": {"textures": {"front": "mekanism:blocks/chemical_injection_chamber/ChemicalInjectionChamberFrontOn"}}, + "true": { + "textures": { + "front": "mekanism:blocks/chemical_injection_chamber/ChemicalInjectionChamberFrontOn", + "west": "mekanism:blocks/chemical_injection_chamber/ChemicalInjectionChamberRightOn", + "east": "mekanism:blocks/chemical_injection_chamber/ChemicalInjectionChamberLeftOn", + "south": "mekanism:blocks/chemical_injection_chamber/ChemicalInjectionChamberBackOn", + "up": "mekanism:blocks/chemical_injection_chamber/ChemicalInjectionChamberTopOn" + } + }, "false": {} }, "inventory": [{}] diff --git a/src/main/resources/assets/mekanism/blockstates/combiner.json b/src/main/resources/assets/mekanism/blockstates/combiner.json index ac80ccb08..8b3235ea5 100644 --- a/src/main/resources/assets/mekanism/blockstates/combiner.json +++ b/src/main/resources/assets/mekanism/blockstates/combiner.json @@ -8,7 +8,8 @@ "west": "mekanism:blocks/combiner/CombinerRight", "east": "mekanism:blocks/combiner/CombinerLeft", "south": "mekanism:blocks/combiner/CombinerBack", - "up": "mekanism:blocks/combiner/CombinerTop" + "up": "mekanism:blocks/combiner/CombinerTop", + "down": "mekanism:blocks/combiner/CombinerBottom" } }, "variants": { @@ -19,7 +20,15 @@ "west": {"y": -90} }, "active": { - "true": {"textures": {"front": "mekanism:blocks/combiner/CombinerFrontOn"}}, + "true": { + "textures": { + "front": "mekanism:blocks/combiner/CombinerFrontOn", + "west": "mekanism:blocks/combiner/CombinerRightOn", + "east": "mekanism:blocks/combiner/CombinerLeftOn", + "south": "mekanism:blocks/combiner/CombinerBackOn", + "up": "mekanism:blocks/combiner/CombinerTopOn" + } + }, "false": {} }, "inventory": [{}] diff --git a/src/main/resources/assets/mekanism/blockstates/crusher.json b/src/main/resources/assets/mekanism/blockstates/crusher.json index a05b0ff6e..097512134 100644 --- a/src/main/resources/assets/mekanism/blockstates/crusher.json +++ b/src/main/resources/assets/mekanism/blockstates/crusher.json @@ -8,7 +8,8 @@ "west": "mekanism:blocks/crusher/CrusherRight", "east": "mekanism:blocks/crusher/CrusherLeft", "south": "mekanism:blocks/crusher/CrusherBack", - "up": "mekanism:blocks/crusher/CrusherTop" + "up": "mekanism:blocks/crusher/CrusherTop", + "down": "mekanism:blocks/crusher/CrusherBottom" } }, "variants": { @@ -19,7 +20,15 @@ "west": {"y": -90} }, "active": { - "true": {"textures": {"front": "mekanism:blocks/crusher/CrusherFrontOn"}}, + "true": { + "textures": { + "front": "mekanism:blocks/crusher/CrusherFrontOn", + "west": "mekanism:blocks/crusher/CrusherRightOn", + "east": "mekanism:blocks/crusher/CrusherLeftOn", + "south": "mekanism:blocks/crusher/CrusherBackOn", + "up": "mekanism:blocks/crusher/CrusherTopOn" + } + }, "false": {} }, "inventory": [{}] diff --git a/src/main/resources/assets/mekanism/blockstates/enrichment_chamber.json b/src/main/resources/assets/mekanism/blockstates/enrichment_chamber.json index c242ed0cc..be67a38b4 100644 --- a/src/main/resources/assets/mekanism/blockstates/enrichment_chamber.json +++ b/src/main/resources/assets/mekanism/blockstates/enrichment_chamber.json @@ -8,7 +8,8 @@ "west": "mekanism:blocks/enrichment_chamber/EnrichmentChamberRight", "east": "mekanism:blocks/enrichment_chamber/EnrichmentChamberLeft", "south": "mekanism:blocks/enrichment_chamber/EnrichmentChamberBack", - "up": "mekanism:blocks/enrichment_chamber/EnrichmentChamberTop" + "up": "mekanism:blocks/enrichment_chamber/EnrichmentChamberTop", + "down": "mekanism:blocks/enrichment_chamber/EnrichmentChamberBottom" } }, "variants": { @@ -19,7 +20,15 @@ "west": {"y": -90} }, "active": { - "true": {"textures": {"front": "mekanism:blocks/enrichment_chamber/EnrichmentChamberFrontOn"}}, + "true": { + "textures": { + "front": "mekanism:blocks/enrichment_chamber/EnrichmentChamberFrontOn", + "west": "mekanism:blocks/enrichment_chamber/EnrichmentChamberRightOn", + "east": "mekanism:blocks/enrichment_chamber/EnrichmentChamberLeftOn", + "south": "mekanism:blocks/enrichment_chamber/EnrichmentChamberBackOn", + "up": "mekanism:blocks/enrichment_chamber/EnrichmentChamberTopOn" + } + }, "false": {} }, "inventory": [{}] diff --git a/src/main/resources/assets/mekanism/textures/blocks/crusher/CrusherBottom.png b/src/main/resources/assets/mekanism/textures/blocks/crusher/CrusherBottom.png new file mode 100644 index 0000000000000000000000000000000000000000..6c7dd2f7947d20190d3af98e56619d9d8ea4fa2b GIT binary patch literal 1427 zcmeAS@N?(olHy`uVBq!ia0vp^3LwnE1SJ1Ryj={WBuiW)N`mv#O3D+9QW+dm@{>{( zJaZG%Q-e|yQz{EjrrIztFz024M3hAM`dB6B=jtVb)aX^@765fKFxc2v6eK2Rr0UTq__OB&@Hb09I0xZL0)vRD^GUf^&XRs)DJWnQpS7p`n7grJkXw zg|U&Tj)IYap{c%srM{tou7RPIp@Ef=fdUjL0c|TvNwW%aaf8|g1^l#~=$>Fbx5 zm+O@q>*W`v>l<2HTIw4Z=^Gj80#)c1SLT%@R_NvxE5l51Ni9w;$}A|!%+FH*nV6WA zUs__T1av9H3%LcpzHo!{ilG4o3^M(S!~%UoJp=vRT#&!Os*6j4QW4I;s=7F&vLIDI zD784hv?v)EA8E=k&A_n3ZxKi#&^1>6MVY`zNz8G{PcF?(%`5SAu~h=f=%r+)SUDLw zJDHl8xj0%lxw;w~0=;i!?&Rub=49;T?BZ-}3Nr(nUN>_$R|8ikQ#WHnS3^TrQzug= zS4#^QLq}(43nw#I6PRAlyyB9?yyR4vy_rCJp?Xd5>a}t%N=+=uFAB-e&w-_YfQiJ`7#Vxpn0iDhDnrDd9hg_(J(5>$T*Ibo*{bdWwMksu`+m=G`}f|&3u z0OY_kQEDDA=M(|6h|^nRdFb$w9!?@!0c283uJN|Nr~X=#Unw z)bden4_Rk$J1whlr3mkx+p+wQZod_C4U{?F7JFTi?{LBlmClD*TZ{hG*!4*iu6h6a zWokWZ-l8%6#7S4mV}{-49=Xof>g{Yw`6Q&C{16v*Q}~H12*p zlQsOnyrkcM?`_DGx|BWZ;-<$xQp8_xd|USV%chPW^CIDsI*6tgnY+&oj&S?Rsx@dIqn= zPdAzRm7T}#y^KkfdsDXCemC!_im=@)&vpJ^k+N@1&x?>%KG|{U&1rnEXPS8b6>t3h z`>wTiy=cJ|t*c(wWRK4~zuf=X(zH$Ue*CQYCjIAm#=isKv!gu46V5&@`gkHpnAa_G tTBXNx@qc^vpF8iod|_B=0qcGy9){J%!8a|EqB%juq^GN&%Q~loCIB?`7c>9> literal 0 HcmV?d00001