Merge branch 'remove_carvablevariation' into dev

Conflicts:
	src/main/java/com/cricketcraft/chisel/api/IMC.java
This commit is contained in:
tterrag1098 committed 2015-04-26 02:43:43 -04:00
commit aac68bd58e
69 files changed
+1542 -1521

No files matched your search

@@ -3,5 +3,5 @@ package com.cricketcraft.chisel.api;
public class ChiselAPIProps {
public static final String VERSION = "0.0.2";
public static String MOD_ID = null; // Set by Chisel
}
@@ -0,0 +1,22 @@
package com.cricketcraft.chisel.api;
import net.minecraft.block.Block;
import net.minecraft.item.ItemStack;
import cpw.mods.fml.common.event.FMLInterModComms;
public class FMPIMC {
public static void registerFMP(Block block) {
registerFMP(block, 0, 15);
}
public static void registerFMP(Block block, int minMeta, int maxMeta) {
for (int c = minMeta; c <= maxMeta; c++) {
registerFMP(block, c);
}
}
public static void registerFMP(Block block, int meta) {
FMLInterModComms.sendMessage("ForgeMicroblock", "microMaterial", new ItemStack(block, 1, meta));
}
}
@@ -1,18 +1,19 @@
package com.cricketcraft.chisel.api;
import com.cricketcraft.chisel.carving.CarvableHelper;
import com.cricketcraft.chisel.carving.CarvableVariation;
import net.minecraft.item.ItemStack;
import net.minecraft.world.IBlockAccess;
import com.cricketcraft.chisel.api.carving.CarvableHelper;
import com.cricketcraft.chisel.api.carving.IVariationInfo;
import com.cricketcraft.chisel.api.rendering.ISubmapManager;
/**
* To be implemented on blocks that can be chiseled and need advanced metadata to variation mapping. Currently not very usable without internal classes.
*/
public interface ICarvable {
/**
* Gets a {@link CarvableVariation} from this block, based on metadata.
* Gets a {@link ISubmapManager} from this block, based on metadata.
* <p>
* Typically you can refer this method to {@link CarvableHelper#getVariation(int)} but this method is provided for more complex metadata handling.
*
@@ -28,16 +29,17 @@ public interface ICarvable {
* Z coord of the block
* @param metadata
* The metadata of the block
* @return The {@link CarvableVariation} that represents this block in the world.
* @return The {@link ISubmapManager} that represents this block in the world.
*/
public CarvableVariation getVariation(IBlockAccess world, int x, int y, int z, int metadata);
public IVariationInfo getVariation(IBlockAccess world, int x, int y, int z, int metadata);
/**
* Gets the {@link CarvableVariation} for this block when it is in item form.
* Gets the {@link ISubmapManager} for this block when it is in item form.
*
* @param stack
* The {@link ItemStack} representing this block;
* @return A {@link CarvableVariation}
* @return A {@link ISubmapManager}
*/
public CarvableVariation getVariation(ItemStack stack);
public IVariationInfo getVariation(ItemStack stack);
}
@@ -54,5 +54,10 @@ public enum IMC {
/**
* The modid of Chisel so you can easily send IMC to this mod.
*/
@Deprecated
public static final String CHISEL_MODID = "chisel";
public static final String getModid() {
return ChiselAPIProps.MOD_ID;
}
}
@@ -0,0 +1,203 @@
package com.cricketcraft.chisel.api.carving;
import java.util.ArrayList;
import java.util.List;
import net.minecraft.block.Block;
import net.minecraft.block.material.Material;
import net.minecraft.client.Minecraft;
import net.minecraft.client.renderer.RenderBlocks;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.client.renderer.texture.TextureMap;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.item.ItemBlock;
import net.minecraft.item.ItemStack;
import net.minecraft.util.IIcon;
import net.minecraft.world.IBlockAccess;
import net.minecraftforge.oredict.OreDictionary;
import com.cricketcraft.chisel.api.ChiselAPIProps;
import com.cricketcraft.chisel.api.FMPIMC;
import com.cricketcraft.chisel.api.rendering.ISubmapManager;
import com.cricketcraft.chisel.api.rendering.TextureType;
import cpw.mods.fml.common.registry.GameRegistry;
public class CarvableHelper {
public static Class<? extends ItemBlock> itemCarvableClass = null;
private Block theBlock;
public ArrayList<IVariationInfo> infoList = new ArrayList<IVariationInfo>();
IVariationInfo[] infoMap = new IVariationInfo[16];
public boolean forbidChiseling = false;
public CarvableHelper(Block block) {
this.theBlock = block;
}
public void addVariation(String description, int metadata, ISubmapManager<? extends RenderBlocks> manager) {
addVariation(description, metadata, null, manager);
}
public void addVariation(String description, int metadata, Block bb) {
addVariation(description, metadata, null, bb, 0, ChiselAPIProps.MOD_ID);
}
public void addVariation(String description, int metadata, Block bb, int blockMeta) {
addVariation(description, metadata, null, bb, blockMeta, ChiselAPIProps.MOD_ID);
}
public void addVariation(String description, int metadata, Block bb, int blockMeta, Material material) {
addVariation(description, metadata, null, bb, blockMeta, ChiselAPIProps.MOD_ID);
}
public void addVariation(String description, int metadata, String texture) {
addVariation(description, metadata, texture, (ISubmapManager<? extends RenderBlocks>) null);
}
public void addVariation(String description, int metadata, String texture, ISubmapManager<? extends RenderBlocks> manager) {
addVariation(description, metadata, texture, null, 0, ChiselAPIProps.MOD_ID, manager);
}
public void addVariation(String description, int metadata, Block bb, String modid) {
addVariation(description, metadata, null, bb, 0, modid);
}
public void addVariation(String description, int metadata, Block bb, int blockMeta, String modid) {
addVariation(description, metadata, null, bb, blockMeta, modid);
}
public void addVariation(String description, int metadata, Block bb, int blockMeta, Material material, String modid) {
addVariation(description, metadata, null, bb, blockMeta, modid);
}
public void addVariation(String description, int metadata, String texture, String modid) {
addVariation(description, metadata, texture, null, 0, modid);
}
public void addVariation(String description, int metadata, String texture, Block block, int blockMeta, String modid) {
addVariation(description, metadata, texture, block, blockMeta, modid, null);
}
public void addVariation(String description, int metadata, String texture, Block block, int blockMeta, String modid, ISubmapManager<? extends RenderBlocks> customManager) {
if (infoList.size() >= 16)
return;
ICarvingVariation var = CarvingUtils.getDefaultVariationFor(theBlock, metadata, metadata);
TextureType type = TextureType.getTypeFor(this, modid, texture);
if (type == TextureType.CUSTOM && customManager == null && block == null) {
throw new IllegalArgumentException(String.format("Could not find texture %s, and no custom texture manager was provided.", texture));
}
IVariationInfo info;
ISubmapManager<?> manager;
if (customManager != null) {
manager = customManager;
} else if (block != null) {
manager = type.createManagerFor(var, block, blockMeta);
} else {
manager = type.createManagerFor(var, texture);
}
info = new VariationInfoBase(var, description, manager);
infoList.add(info);
infoMap[metadata] = info;
}
public IVariationInfo getVariation(int metadata) {
if (metadata < 0 || metadata > 15)
metadata = 0;
IVariationInfo info = infoMap[metadata];
if (info == null)
return null;
return info;
}
public IIcon getIcon(int side, int metadata) {
if (metadata < 0 || metadata > 15)
metadata = 0;
IVariationInfo info = infoMap[metadata];
if (info == null)
return getMissingIcon();
return info.getSubmapManager().getIcon(side, metadata);
}
public IIcon getIcon(IBlockAccess world, int x, int y, int z, int side) {
int metadata = world.getBlockMetadata(x, y, z);
if (metadata < 0 || metadata > 15)
metadata = 0;
IVariationInfo info = infoMap[metadata];
if (info == null)
return getMissingIcon();
return info.getSubmapManager().getIcon(world, x, y, z, side);
}
public void registerAll(Block block, String name) {
registerAll(block, name, itemCarvableClass);
}
public void registerBlock(Block block, String name) {
registerBlock(block, name, itemCarvableClass);
}
void registerBlock(Block block, String name, Class<? extends ItemBlock> cl) {
block.setBlockName("chisel." + name);
GameRegistry.registerBlock(block, cl, name);
}
public void registerAll(Block block, String name, Class<? extends ItemBlock> cl) {
registerBlock(block, name, cl);
registerVariations(name, block);
}
public void registerVariations(String name, Block block) {
for (IVariationInfo info : infoList) {
registerVariation(name, info);
}
}
public void registerVariation(String name, IVariationInfo info) {
Block block = info.getVariation().getBlock();
if (block.renderAsNormalBlock() || block.isOpaqueCube() || block.isNormalCube()) {
FMPIMC.registerFMP(block, info.getVariation().getBlockMeta());
}
if (forbidChiseling)
return;
CarvingUtils.getChiselRegistry().addVariation(name, info.getVariation());
}
public void registerBlockIcons(String modName, Block block, IIconRegister register) {
for (IVariationInfo info : infoList) {
info.getSubmapManager().registerIcons(modName, block, register);
}
}
public void registerSubBlocks(Block block, CreativeTabs tabs, List<ItemStack> list) {
for (IVariationInfo info : infoList) {
list.add(new ItemStack(block, 1, info.getVariation().getItemMeta()));
}
}
public void registerOre(String ore) {
OreDictionary.registerOre(ore, infoList.get(0).getVariation().getBlock());
}
public IIcon getMissingIcon() {
return ((TextureMap) Minecraft.getMinecraft().getTextureManager().getTexture(TextureMap.locationBlocksTexture)).getAtlasSprite("missingno");
}
}
@@ -1,9 +1,14 @@
package com.cricketcraft.chisel.api.carving;
import java.lang.reflect.Field;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import net.minecraft.block.Block;
import net.minecraft.item.ItemStack;
import com.google.common.collect.Lists;
public class CarvingUtils {
/**
@@ -30,56 +35,141 @@ public class CarvingUtils {
return new ItemStack(variation.getBlock(), 1, variation.getItemMeta());
}
private static Field _chisel;
private static boolean registryErrored = false;
private static final String CARVING_CLASS = "com.cricketcraft.chisel.carving.Carving";
private static Class<ICarvableHelper> _carvableHelper;
private static boolean helperErrored = false;
private static final String CARVABLE_HELPER_CLASS = "com.cricketcraft.carving.CarvableHelper";
public static ICarvingRegistry chisel;
/**
* @return The instance of the chisel carving registry from the chisel mod.
* <p>
* If chisel is not installed or some other error occurs this will return null.
* If chisel is not installed this will return null.
*/
public static ICarvingRegistry getChiselRegistry() {
if (registryErrored) {
return null;
}
try {
if (_chisel == null) {
_chisel = Class.forName(CARVING_CLASS).getDeclaredField("chisel");
}
return (ICarvingRegistry) _chisel.get(null);
} catch (Exception e) {
e.printStackTrace();
registryErrored = true;
return getChiselRegistry();
}
return chisel;
}
/**
* @return An instance of an {@link ICarvableHelper}.
* <p>
* If chisel is not installed or some other error occurs this will return null.
* Creates a standard {@link ICarvingVariation} for the given data. Use this if you do not need any custom behavior in your own variation.
*
* @param block
* The block of the variation
* @param metadata
* The metadata of both the block and item
* @param order
* The sorting order.
* @return A standard {@link ICarvingVariation} instance.
*/
@SuppressWarnings("unchecked")
public static ICarvableHelper getCarvableHelperInstance() {
if (helperErrored) {
return null;
public static ICarvingVariation getDefaultVariationFor(Block block, int metadata, int order) {
return new SimpleCarvingVariation(block, metadata, order);
}
/**
* Creates a standard {@link ICarvingGroup} for the given name. Use this if you do not need any custom behavior in your own group.
*
* @param name
* The name of the group.
* @return A standard {@link ICarvingGroup} instance.
*/
public static ICarvingGroup getDefaultGroupFor(String name) {
return new SimpleCarvingGroup(name);
}
public static class SimpleCarvingVariation implements ICarvingVariation {
private int order;
private Block block;
private int meta;
private int damage;
public SimpleCarvingVariation(Block block, int metadata, int order) {
this.order = order;
this.block = block;
this.meta = metadata;
this.damage = metadata;
}
try {
if (_carvableHelper == null) {
_carvableHelper = (Class<ICarvableHelper>) Class.forName(CARVABLE_HELPER_CLASS);
}
return _carvableHelper.newInstance();
} catch (Exception e) {
e.printStackTrace();
helperErrored = true;
return getCarvableHelperInstance();
@Override
public Block getBlock() {
return block;
}
@Override
public int getBlockMeta() {
return meta;
}
@Override
public int getItemMeta() {
return damage;
}
@Override
public int getOrder() {
return order;
}
}
public static class SimpleCarvingGroup implements ICarvingGroup {
private String name;
private String sound;
private String oreName;
private List<ICarvingVariation> variations = Lists.newArrayList();
public SimpleCarvingGroup(String name) {
this.name = name;
}
public List<ICarvingVariation> getVariations() {
return Lists.newArrayList(variations);
}
@Override
public void addVariation(ICarvingVariation variation) {
variations.add(variation);
Collections.sort(variations, new Comparator<ICarvingVariation>() {
@Override
public int compare(ICarvingVariation o1, ICarvingVariation o2) {
return CarvingUtils.compare(o1, o2);
}
});
}
@Override
public boolean removeVariation(ICarvingVariation variation) {
ICarvingVariation toRemove = null;
for (ICarvingVariation v : variations) {
if (v.getBlock() == variation.getBlock() && v.getBlockMeta() == variation.getBlockMeta()) {
toRemove = v;
}
}
return toRemove == null ? false : variations.remove(toRemove);
}
@Override
public String getName() {
return name;
}
@Override
public String getSound() {
return sound;
}
@Override
public void setSound(String sound) {
this.sound = sound;
}
@Override
public String getOreName() {
return oreName;
}
@Override
public void setOreName(String oreName) {
this.oreName = oreName;
}
}
}
@@ -1,6 +0,0 @@
package com.cricketcraft.chisel.api.carving;
public interface ICarvableHelper {
}
@@ -0,0 +1,17 @@
package com.cricketcraft.chisel.api.carving;
import net.minecraft.client.renderer.RenderBlocks;
import com.cricketcraft.chisel.api.rendering.ISubmapManager;
import com.cricketcraft.chisel.api.rendering.TextureType;
public interface IVariationInfo {
ISubmapManager<? extends RenderBlocks> getSubmapManager();
ICarvingVariation getVariation();
String getDescription();
TextureType getType();
}
@@ -0,0 +1,46 @@
package com.cricketcraft.chisel.api.carving;
import net.minecraft.client.renderer.RenderBlocks;
import net.minecraft.util.StatCollector;
import com.cricketcraft.chisel.api.rendering.ISubmapManager;
import com.cricketcraft.chisel.api.rendering.TextureType;
public class VariationInfoBase implements IVariationInfo {
private ICarvingVariation variation;
private String unlocDesc;
private ISubmapManager<? extends RenderBlocks> manager;
private TextureType type;
public VariationInfoBase(ICarvingVariation variation, String unlocDesc, ISubmapManager<? extends RenderBlocks> manager) {
this(variation, unlocDesc, manager, TextureType.CUSTOM);
}
public VariationInfoBase(ICarvingVariation variation, String unlocDesc, ISubmapManager<? extends RenderBlocks> manager, TextureType type) {
this.variation = variation;
this.unlocDesc = unlocDesc;
this.manager = manager;
this.type = type;
}
@Override
public ICarvingVariation getVariation() {
return variation;
}
@Override
public String getDescription() {
return StatCollector.translateToLocal(unlocDesc);
}
@Override
public ISubmapManager<? extends RenderBlocks> getSubmapManager() {
return manager;
}
@Override
public TextureType getType() {
return type;
}
}
@@ -1,4 +1,4 @@
package com.cricketcraft.chisel.api.client;
package com.cricketcraft.chisel.api.rendering;
import gnu.trove.map.TIntObjectMap;
import gnu.trove.map.hash.TIntObjectHashMap;
@@ -12,7 +12,7 @@ import net.minecraftforge.common.util.ForgeDirection;
import com.cricketcraft.chisel.api.IFacade;
import com.google.common.collect.Maps;
import static com.cricketcraft.chisel.api.client.Dir.*;
import static com.cricketcraft.chisel.api.rendering.Dir.*;
// @formatter:off
/**
@@ -68,15 +68,15 @@ import static com.cricketcraft.chisel.api.client.Dir.*;
public class CTM {
/** Some hardcoded offset values for the different corner indeces */
private int[] submapOffsets = { 4, 5, 1, 0 };
private TIntObjectMap<Dir[]> submapMap = new TIntObjectHashMap<Dir[]>();
private static int[] submapOffsets = { 4, 5, 1, 0 };
private static TIntObjectMap<Dir[]> submapMap = new TIntObjectHashMap<Dir[]>();
private static EnumMap<Dir, Boolean> connectionMap = Maps.newEnumMap(Dir.class);
/** For use via the Chisel 2 config only, altering this could cause unintended behavior */
public static boolean disableObscuredFaceCheckConfig = false;
public Boolean disableObscuredFaceCheck = null;
private CTM() {
static {
for (Dir dir : Dir.VALUES) {
connectionMap.put(dir, false);
}
@@ -86,6 +86,9 @@ public class CTM {
submapMap.put(2, new Dir[] { TOP, RIGHT, TOP_RIGHT });
submapMap.put(3, new Dir[] { TOP, LEFT, TOP_LEFT });
}
private CTM() {
}
public static CTM getInstance() {
return new CTM();
@@ -0,0 +1,8 @@
package com.cricketcraft.chisel.api.rendering;
public class ClientUtils {
public static int renderCTMId;
}
@@ -1,4 +1,4 @@
package com.cricketcraft.chisel.api.client;
package com.cricketcraft.chisel.api.rendering;
import net.minecraft.block.Block;
import net.minecraft.world.IBlockAccess;
@@ -1,11 +1,13 @@
package com.cricketcraft.chisel.api.client;
package com.cricketcraft.chisel.api.rendering;
import net.minecraft.block.Block;
import net.minecraft.client.renderer.RenderBlocks;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.util.IIcon;
import net.minecraft.world.IBlockAccess;
import net.minecraftforge.common.util.ForgeDirection;
public interface ISubmapManager {
public interface ISubmapManager<T extends RenderBlocks> {
/**
* Gets the icon for item rendering, based on side and item metadata.
@@ -34,4 +36,10 @@ public interface ISubmapManager {
* The IIconRegister instance.
*/
void registerIcons(String modName, Block block, IIconRegister register);
T createRenderContext(RenderBlocks rendererOld, IBlockAccess world);
void preRenderSide(T renderer, IBlockAccess world, int x, int y, int z, ForgeDirection side);
void postRenderSide(T renderer, IBlockAccess world, int x, int y, int z, ForgeDirection side);
}
@@ -0,0 +1,528 @@
package com.cricketcraft.chisel.api.rendering;
import net.minecraft.block.Block;
import net.minecraft.client.renderer.RenderBlocks;
import net.minecraft.client.renderer.Tessellator;
import net.minecraft.util.IIcon;
import net.minecraftforge.common.util.ForgeDirection;
import static com.cricketcraft.chisel.api.rendering.RenderBlocksCTM.SubSide.*;
import static com.cricketcraft.chisel.api.rendering.RenderBlocksCTM.Vert.*;
public class RenderBlocksCTM extends RenderBlocks {
/**
* An enum for all possible 26 sub-side vertices.
*
* The naming scheme is as follows:
*
* ZERO is a special case, it is the absolute min point of the block. X, Y, Z, or any combination means that the axes listed in the name are at 1. X, Y, Z, or any combination followed by HALF
* means that those axes are at 0.5. X, Y, Z, or any combination after a HALF means those axes are at 1.
*/
protected enum Vert {
// @formatter:off
ZERO(0, 0, 0),
XYZ(1, 1, 1),
X(1, 0, 0),
Y(0, 1, 0),
Z(0, 0, 1),
XY(1, 1, 0),
YZ(0, 1, 1),
XZ(1, 0, 1),
X_HALF(0.5, 0, 0),
Y_HALF(0, 0.5, 0),
Z_HALF(0, 0, 0.5),
XY_HALF(0.5, 0.5, 0),
YZ_HALF(0, 0.5, 0.5),
XZ_HALF(0.5, 0, 0.5),
X_HALF_Y(0.5, 1, 0),
X_HALF_Z(0.5, 0, 1),
Y_HALF_X(1, 0.5, 0),
Y_HALF_Z(0, 0.5, 1),
Z_HALF_X(1, 0, 0.5),
Z_HALF_Y(0, 1, 0.5),
X_HALF_YZ(0.5, 1, 1),
Y_HALF_XZ(1, 0.5, 1),
Z_HALF_XY(1, 1, 0.5),
XY_HALF_Z(0.5, 0.5, 1),
YZ_HALF_X(1, 0.5, 0.5),
XZ_HALF_Y(0.5, 1, 0.5);
// @formatter:on
private double x, y, z;
private Vert(double x, double y, double z) {
this.x = x;
this.y = y;
this.z = z;
}
private static double u, v, xDiff, yDiff, zDiff, uDiff, vDiff;
void render(RenderBlocksCTM inst, ForgeDirection normal, int cacheID) {
if (inst.enableAO) {
inst.tessellator.setColorOpaque_F(inst.redCache[cacheID], inst.grnCache[cacheID], inst.bluCache[cacheID]);
inst.tessellator.setBrightness(inst.lightingCache[cacheID]);
}
u = cacheID == 1 || cacheID == 2 ? inst.maxU : inst.minU;
v = cacheID < 2 ? inst.maxV : inst.minV;
uDiff = inst.maxU - inst.minU;
vDiff = inst.maxV - inst.minV;
if (inst.renderMinX + inst.renderMinY + inst.renderMinZ != 0 || inst.renderMaxX + inst.renderMaxY + inst.renderMaxZ != 3) {
boolean uMin = u == inst.minU;
boolean vMin = v == inst.minV;
xDiff = inst.renderMaxX - inst.renderMinX;
yDiff = inst.renderMaxY - inst.renderMinY;
zDiff = inst.renderMaxZ - inst.renderMinZ;
if (normal.offsetY != 0) {
uDiff *= uMin ? inst.renderMinX : 1 - inst.renderMaxX;
vDiff *= vMin ? inst.renderMinZ : 1 - inst.renderMaxZ;
} else if (normal.offsetX != 0) {
uDiff *= uMin ? inst.renderMinZ : 1 - inst.renderMaxZ;
vDiff *= vMin ? inst.renderMinY : 1 - inst.renderMaxY;
} else if (normal.offsetZ != 0) {
uDiff *= uMin ? inst.renderMinX : 1 - inst.renderMaxX;
vDiff *= vMin ? inst.renderMinY : 1 - inst.renderMaxY;
}
u = u == inst.minU ? inst.minU + uDiff : inst.maxU - uDiff;
v = v == inst.minV ? inst.minV + vDiff : inst.maxV - vDiff;
} else {
xDiff = yDiff = zDiff = 1;
}
inst.tessellator.addVertexWithUV(inst.renderMinX + (x * xDiff), inst.renderMinY + (y * yDiff), inst.renderMinZ + (z * zDiff), u, v);
}
}
/**
* Each side is divided into 4 sub-sides. LB(left bottom), RB(right bottom), LT(right top), and RT(right top).
*
* Each sub-side contains 4 {@link Vert} objects representing its position on the block.
*/
protected enum SubSide {
// @formatter:off
XNEG_LB(ZERO, Z_HALF, YZ_HALF, Y_HALF), XNEG_RB(Z_HALF, Z, Y_HALF_Z, YZ_HALF), XNEG_RT(YZ_HALF, Y_HALF_Z, YZ, Z_HALF_Y), XNEG_LT(Y_HALF, YZ_HALF, Z_HALF_Y, Y),
XPOS_LB(XZ, Z_HALF_X, YZ_HALF_X, Y_HALF_XZ), XPOS_RB(Z_HALF_X, X, Y_HALF_X, YZ_HALF_X), XPOS_RT(YZ_HALF_X, Y_HALF_X, XY, Z_HALF_XY), XPOS_LT(Y_HALF_XZ, YZ_HALF_X, Z_HALF_XY, XYZ),
ZNEG_LB(X, X_HALF, XY_HALF, Y_HALF_X), ZNEG_RB(X_HALF, ZERO, Y_HALF, XY_HALF), ZNEG_RT(XY_HALF, Y_HALF, Y, X_HALF_Y), ZNEG_LT(Y_HALF_X, XY_HALF, X_HALF_Y, XY),
ZPOS_LB(Z, X_HALF_Z, XY_HALF_Z, Y_HALF_Z), ZPOS_RB(X_HALF_Z, XZ, Y_HALF_XZ, XY_HALF_Z), ZPOS_RT(XY_HALF_Z, Y_HALF_XZ, XYZ, X_HALF_YZ), ZPOS_LT(Y_HALF_Z, XY_HALF_Z, X_HALF_YZ, YZ),
YNEG_LB(ZERO, X_HALF, XZ_HALF, Z_HALF), YNEG_RB(X_HALF, X, Z_HALF_X, XZ_HALF), YNEG_RT(XZ_HALF, Z_HALF_X, XZ, X_HALF_Z), YNEG_LT(Z_HALF, XZ_HALF, X_HALF_Z, Z),
YPOS_LB(YZ, X_HALF_YZ, XZ_HALF_Y, Z_HALF_Y), YPOS_RB(X_HALF_YZ, XYZ, Z_HALF_XY, XZ_HALF_Y), YPOS_RT(XZ_HALF_Y, Z_HALF_XY, XY, X_HALF_Y), YPOS_LT(Z_HALF_Y, XZ_HALF_Y, X_HALF_Y, Y);
// @formatter:on
private Vert xmin, xmax, ymin, ymax;
private ForgeDirection normal;
SubSide(Vert xmin, Vert ymin, Vert ymax, Vert xmax) {
this.xmin = xmin;
this.ymin = ymin;
this.ymax = ymax;
this.xmax = xmax;
this.normal = calcNormal();
}
private ForgeDirection calcNormal() {
double xTot = xmin.x + xmax.x + ymin.x + ymax.x;
double yTot = xmin.y + xmax.y + ymin.y + ymax.y;
double zTot = xmin.z + xmax.z + ymin.z + ymax.z;
if (xTot % 4 == 0) {
return xTot > 0 ? ForgeDirection.EAST : ForgeDirection.WEST;
} else if (yTot % 4 == 0) {
return yTot > 0 ? ForgeDirection.UP : ForgeDirection.DOWN;
} else if (zTot % 4 == 0) {
return zTot > 0 ? ForgeDirection.SOUTH : ForgeDirection.NORTH;
}
return ForgeDirection.UNKNOWN;
}
void render(RenderBlocksCTM inst) {
xmin.render(inst, normal, 0);
ymin.render(inst, normal, 1);
ymax.render(inst, normal, 2);
xmax.render(inst, normal, 3);
}
}
protected static CTM ctm = CTM.getInstance();
// globals added to save the JVM some trouble. No need to constantly create
// and destroy ints if we don't have to
protected int blockLightBitChannel = 0;
protected int redBitChannel = 0;
protected int greenBitChannel = 0;
protected int blueBitChannel = 0;
protected int sunlightBitChannel = 0;
public RenderBlocksCTM() {
super();
renderMaxX = renderMaxY = renderMaxZ = 1;
}
protected Tessellator tessellator;
protected double minU, maxU;
protected double minV, maxV;
protected int[] lightingCache = new int[4];
protected float[] redCache = new float[4];
protected float[] grnCache = new float[4];
protected float[] bluCache = new float[4];
public TextureSubmap submap;
public TextureSubmap submapSmall;
public RenderBlocks rendererOld;
public ISubmapManager<RenderBlocksCTM> manager;
protected int[][] lightmap = new int[3][3];
protected float[][] redmap = new float[3][3];
protected float[][] grnmap = new float[3][3];
protected float[][] blumap = new float[3][3];
protected int bx, by, bz;
@Override
public boolean renderStandardBlock(Block block, int x, int y, int z) {
bx = x;
by = y;
bz = z;
tessellator = Tessellator.instance;
tessellator.setColorOpaque_F(1.0F, 1.0F, 1.0F);
tessellator.addTranslation(x, y, z);
boolean res = super.renderStandardBlock(block, x, y, z);
tessellator.addTranslation(-x, -y, -z);
return res;
}
/* @formatter:off
* This method fills a 3x3 grid of light values based on the four corners, by averaging them together.
*
* 2 TL x TR
*
* 1 x x x
*
* 0 BL x BR
* 0 1 2
*
* Note: Variable names mean nothing... don't touch
*
* ._.
*
* shakes fist in anger
*/
// @formatter:on
protected void fillLightmap(int bottomLeft, int bottomRight, int topRight, int topLeft) {
lightmap[0][0] = bottomLeft;
lightmap[2][0] = bottomRight;
lightmap[2][2] = topRight;
lightmap[0][2] = topLeft;
lightmap[1][0] = avg(bottomLeft, bottomRight);
lightmap[2][1] = avg(bottomRight, topRight);
lightmap[1][2] = avg(topRight, topLeft);
lightmap[0][1] = avg(topLeft, bottomLeft);
lightmap[1][1] = avg(bottomLeft, bottomRight, topRight, topLeft);
}
protected void fillColormap(float bottomLeft, float bottomRight, float topRight, float topLeft, float[][] map) {
map[0][0] = bottomLeft;
map[2][0] = bottomRight;
map[2][2] = topRight;
map[0][2] = topLeft;
map[1][0] = (bottomLeft + bottomRight) / 2.0F;
map[2][1] = (bottomRight + topRight) / 2.0F;
map[1][2] = (topRight + topLeft) / 2.0F;
map[0][1] = (topLeft + bottomLeft) / 2.0F;
map[1][1] = (bottomLeft + bottomRight + topRight + topLeft) / 4.0F;
}
protected void getLight(int x, int y) {
lightingCache[0] = lightmap[0 + x][0 + y];
lightingCache[1] = lightmap[1 + x][0 + y];
lightingCache[2] = lightmap[1 + x][1 + y];
lightingCache[3] = lightmap[0 + x][1 + y];
redCache[0] = redmap[0 + x][0 + y];
redCache[1] = redmap[1 + x][0 + y];
redCache[2] = redmap[1 + x][1 + y];
redCache[3] = redmap[0 + x][1 + y];
grnCache[0] = grnmap[0 + x][0 + y];
grnCache[1] = grnmap[1 + x][0 + y];
grnCache[2] = grnmap[1 + x][1 + y];
grnCache[3] = grnmap[0 + x][1 + y];
bluCache[0] = blumap[0 + x][0 + y];
bluCache[1] = blumap[1 + x][0 + y];
bluCache[2] = blumap[1 + x][1 + y];
bluCache[3] = blumap[0 + x][1 + y];
}
/**
* This works around a bug in CLC atm
*/
private int avg(int... lightVals) {
blockLightBitChannel = 0;
redBitChannel = 0;
greenBitChannel = 0;
blueBitChannel = 0;
sunlightBitChannel = 0;
for (int light : lightVals) {
blockLightBitChannel += (light & 0xFF);
redBitChannel += (light & 0xF00);
greenBitChannel += (light & 0xF000);
blueBitChannel += (light & 0xF0000);
sunlightBitChannel += (light & 0xF00000);
}
return ((blockLightBitChannel / lightVals.length) & 0xFF) | ((redBitChannel / lightVals.length) & 0xF00) | ((greenBitChannel / lightVals.length) & 0xF000)
| ((blueBitChannel / lightVals.length) & 0xF0000) | ((sunlightBitChannel / lightVals.length) & 0xF00000);
}
protected void side(SubSide side, int iconIndex) {
IIcon icon;
TextureSubmap map;
if (iconIndex >= 16) {
iconIndex -= 16;
map = submapSmall;
} else {
map = submap;
}
int x = iconIndex % map.getWidth();
int y = iconIndex / map.getHeight();
icon = map.getSubIcon(x, y);
double umax = icon.getMaxU();
double umin = icon.getMinU();
double vmax = icon.getMaxV();
double vmin = icon.getMinV();
minU = umin;
maxU = umax;
minV = vmin;
maxV = vmax;
// uCache[0] = umin;
// uCache[1] = umax;
// uCache[2] = umax;
// uCache[3] = umin;
//
// vCache[0] = vmax;
// vCache[1] = vmax;
// vCache[2] = vmin;
// vCache[3] = vmin;
side.render(this);
}
@Override
public void renderFaceXNeg(Block block, double x, double y, double z, IIcon icon) {
if (rendererOld != null && rendererOld.hasOverrideBlockTexture()) {
IIcon i = rendererOld.overrideBlockTexture;
tessellator.addVertexWithUV(renderMinX, renderMaxY, renderMinZ, i.getMinU(), i.getMinV());
tessellator.addVertexWithUV(renderMinX, renderMinY, renderMinZ, i.getMinU(), i.getMaxV());
tessellator.addVertexWithUV(renderMinX, renderMinY, renderMaxZ, i.getMaxU(), i.getMaxV());
tessellator.addVertexWithUV(renderMinX, renderMaxY, renderMaxZ, i.getMaxU(), i.getMinV());
} else {
int tex[] = ctm.getSubmapIndices(blockAccess, bx, by, bz, 4);
pre(ForgeDirection.WEST);
fillLightmap(brightnessBottomRight, brightnessTopRight, brightnessTopLeft, brightnessBottomLeft);
fillColormap(colorRedBottomRight, colorRedTopRight, colorRedTopLeft, colorRedBottomLeft, redmap);
fillColormap(colorGreenBottomRight, colorGreenTopRight, colorGreenTopLeft, colorGreenBottomLeft, grnmap);
fillColormap(colorBlueBottomRight, colorBlueTopRight, colorBlueTopLeft, colorBlueBottomLeft, blumap);
getLight(0, 0);
side(XNEG_LB, tex[0]);
getLight(1, 0);
side(XNEG_RB, tex[1]);
getLight(1, 1);
side(XNEG_RT, tex[2]);
getLight(0, 1);
side(XNEG_LT, tex[3]);
post(ForgeDirection.WEST);
}
}
@Override
public void renderFaceXPos(Block block, double x, double y, double z, IIcon icon) {
if (rendererOld != null && rendererOld.hasOverrideBlockTexture()) {
IIcon i = rendererOld.overrideBlockTexture;
tessellator.addVertexWithUV(renderMaxX, renderMaxY, renderMaxZ, i.getMaxU(), i.getMinV());
tessellator.addVertexWithUV(renderMaxX, renderMinY, renderMaxZ, i.getMaxU(), i.getMaxV());
tessellator.addVertexWithUV(renderMaxX, renderMinY, renderMinZ, i.getMinU(), i.getMaxV());
tessellator.addVertexWithUV(renderMaxX, renderMaxY, renderMinZ, i.getMinU(), i.getMinV());
} else {
int tex[] = ctm.getSubmapIndices(blockAccess, bx, by, bz, 5);
pre(ForgeDirection.EAST);
fillLightmap(brightnessTopLeft, brightnessBottomLeft, brightnessBottomRight, brightnessTopRight);
fillColormap(colorRedTopLeft, colorRedBottomLeft, colorRedBottomRight, colorRedTopRight, redmap);
fillColormap(colorGreenTopLeft, colorGreenBottomLeft, colorGreenBottomRight, colorGreenTopRight, grnmap);
fillColormap(colorBlueTopLeft, colorBlueBottomLeft, colorBlueBottomRight, colorBlueTopRight, blumap);
getLight(0, 0);
side(XPOS_LB, tex[0]);
getLight(1, 0);
side(XPOS_RB, tex[1]);
getLight(1, 1);
side(XPOS_RT, tex[2]);
getLight(0, 1);
side(XPOS_LT, tex[3]);
post(ForgeDirection.EAST);
}
}
@Override
public void renderFaceZNeg(Block block, double x, double y, double z, IIcon icon) {
if (rendererOld != null && rendererOld.hasOverrideBlockTexture()) {
IIcon i = rendererOld.overrideBlockTexture;
tessellator.addVertexWithUV(renderMaxX, renderMaxY, renderMinZ, i.getMaxU(), i.getMinV());
tessellator.addVertexWithUV(renderMaxX, renderMinY, renderMinZ, i.getMaxU(), i.getMaxV());
tessellator.addVertexWithUV(renderMinX, renderMinY, renderMinZ, i.getMinU(), i.getMaxV());
tessellator.addVertexWithUV(renderMinX, renderMaxY, renderMinZ, i.getMinU(), i.getMinV());
} else {
int tex[] = ctm.getSubmapIndices(blockAccess, bx, by, bz, 2);
pre(ForgeDirection.NORTH);
fillLightmap(brightnessBottomRight, brightnessTopRight, brightnessTopLeft, brightnessBottomLeft);
fillColormap(colorRedBottomRight, colorRedTopRight, colorRedTopLeft, colorRedBottomLeft, redmap);
fillColormap(colorGreenBottomRight, colorGreenTopRight, colorGreenTopLeft, colorGreenBottomLeft, grnmap);
fillColormap(colorBlueBottomRight, colorBlueTopRight, colorBlueTopLeft, colorBlueBottomLeft, blumap);
getLight(0, 0);
side(ZNEG_LB, tex[0]);
getLight(1, 0);
side(ZNEG_RB, tex[1]);
getLight(1, 1);
side(ZNEG_RT, tex[2]);
getLight(0, 1);
side(ZNEG_LT, tex[3]);
post(ForgeDirection.NORTH);
}
}
@Override
public void renderFaceZPos(Block block, double x, double y, double z, IIcon icon) {
if (rendererOld != null && rendererOld.hasOverrideBlockTexture()) {
IIcon i = rendererOld.overrideBlockTexture;
tessellator.addVertexWithUV(renderMinX, renderMaxY, renderMaxZ, i.getMinU(), i.getMinV());
tessellator.addVertexWithUV(renderMinX, renderMinY, renderMaxZ, i.getMinU(), i.getMaxV());
tessellator.addVertexWithUV(renderMaxX, renderMinY, renderMaxZ, i.getMaxU(), i.getMaxV());
tessellator.addVertexWithUV(renderMaxX, renderMaxY, renderMaxZ, i.getMaxU(), i.getMinV());
} else {
int tex[] = ctm.getSubmapIndices(blockAccess, bx, by, bz, 3);
pre(ForgeDirection.SOUTH);
fillLightmap(brightnessBottomLeft, brightnessBottomRight, brightnessTopRight, brightnessTopLeft);
fillColormap(colorRedBottomLeft, colorRedBottomRight, colorRedTopRight, colorRedTopLeft, redmap);
fillColormap(colorGreenBottomLeft, colorGreenBottomRight, colorGreenTopRight, colorGreenTopLeft, grnmap);
fillColormap(colorBlueBottomLeft, colorBlueBottomRight, colorBlueTopRight, colorBlueTopLeft, blumap);
getLight(0, 0);
side(ZPOS_LB, tex[0]);
getLight(1, 0);
side(ZPOS_RB, tex[1]);
getLight(1, 1);
side(ZPOS_RT, tex[2]);
getLight(0, 1);
side(ZPOS_LT, tex[3]);
post(ForgeDirection.SOUTH);
}
}
@Override
public void renderFaceYNeg(Block block, double x, double y, double z, IIcon icon) {
if (rendererOld != null && rendererOld.hasOverrideBlockTexture()) {
IIcon i = rendererOld.overrideBlockTexture;
tessellator.addVertexWithUV(renderMinX, renderMinY, renderMaxZ, i.getMinU(), i.getMaxV());
tessellator.addVertexWithUV(renderMinX, renderMinY, renderMinZ, i.getMinU(), i.getMinV());
tessellator.addVertexWithUV(renderMaxX, renderMinY, renderMinZ, i.getMaxU(), i.getMinV());
tessellator.addVertexWithUV(renderMaxX, renderMinY, renderMaxZ, i.getMaxU(), i.getMaxV());
} else {
int tex[] = ctm.getSubmapIndices(blockAccess, bx, by, bz, 0);
pre(ForgeDirection.DOWN);
fillLightmap(brightnessBottomLeft, brightnessBottomRight, brightnessTopRight, brightnessTopLeft);
fillColormap(colorRedBottomLeft, colorRedBottomRight, colorRedTopRight, colorRedTopLeft, redmap);
fillColormap(colorGreenBottomLeft, colorGreenBottomRight, colorGreenTopRight, colorGreenTopLeft, grnmap);
fillColormap(colorBlueBottomLeft, colorBlueBottomRight, colorBlueTopRight, colorBlueTopLeft, blumap);
getLight(0, 0);
side(YNEG_LB, tex[0]);
getLight(1, 0);
side(YNEG_RB, tex[1]);
getLight(1, 1);
side(YNEG_RT, tex[2]);
getLight(0, 1);
side(YNEG_LT, tex[3]);
post(ForgeDirection.DOWN);
}
}
@Override
public void renderFaceYPos(Block block, double x, double y, double z, IIcon icon) {
if (rendererOld != null && rendererOld.hasOverrideBlockTexture()) {
IIcon i = rendererOld.overrideBlockTexture;
tessellator.addVertexWithUV(renderMinX, renderMaxY, renderMinZ, i.getMinU(), i.getMinV());
tessellator.addVertexWithUV(renderMinX, renderMaxY, renderMaxZ, i.getMinU(), i.getMaxV());
tessellator.addVertexWithUV(renderMaxX, renderMaxY, renderMaxZ, i.getMaxU(), i.getMaxV());
tessellator.addVertexWithUV(renderMaxX, renderMaxY, renderMinZ, i.getMaxU(), i.getMinV());
} else {
int tex[] = ctm.getSubmapIndices(blockAccess, bx, by, bz, 1);
pre(ForgeDirection.UP);
fillLightmap(brightnessTopRight, brightnessTopLeft, brightnessBottomLeft, brightnessBottomRight);
fillColormap(colorRedTopRight, colorRedTopLeft, colorRedBottomLeft, colorRedBottomRight, redmap);
fillColormap(colorGreenTopRight, colorGreenTopLeft, colorGreenBottomLeft, colorGreenBottomRight, grnmap);
fillColormap(colorBlueTopRight, colorBlueTopLeft, colorBlueBottomLeft, colorBlueBottomRight, blumap);
getLight(0, 0);
side(YPOS_LB, tex[0]);
getLight(1, 0);
side(YPOS_RB, tex[1]);
getLight(1, 1);
side(YPOS_RT, tex[2]);
getLight(0, 1);
side(YPOS_LT, tex[3]);
post(ForgeDirection.UP);
}
}
protected void pre(ForgeDirection face) {
manager.preRenderSide(this, blockAccess, bx, by, bz, face);
}
protected void post(ForgeDirection face) {
manager.postRenderSide(this, blockAccess, bx, by, bz, face);
}
}
@@ -1,4 +1,4 @@
package com.cricketcraft.chisel.api.client;
package com.cricketcraft.chisel.api.rendering;
import java.util.List;
@@ -79,9 +79,11 @@ public class TextureSubmap {
*/
@SubscribeEvent
public final void TexturesStitched(TextureStitchEvent.Post event) {
for (int x = 0; x < width; x++) {
for (int y = 0; y < height; y++) {
icons[x][y] = new TextureVirtual(getBaseIcon(), width, height, x, y);
for (TextureSubmap ts : submaps) {
for (int x = 0; x < ts.width; x++) {
for (int y = 0; y < ts.height; y++) {
ts.icons[x][y] = new TextureVirtual(ts.getBaseIcon(), ts.width, ts.height, x, y);
}
}
}
}
@@ -0,0 +1,436 @@
package com.cricketcraft.chisel.api.rendering;
import java.util.Random;
import net.minecraft.block.Block;
import net.minecraft.client.Minecraft;
import net.minecraft.client.renderer.RenderBlocks;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.util.IIcon;
import net.minecraft.util.ResourceLocation;
import net.minecraft.world.IBlockAccess;
import net.minecraftforge.common.util.ForgeDirection;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.tuple.Pair;
import org.apache.commons.lang3.tuple.Triple;
import com.cricketcraft.chisel.api.carving.CarvableHelper;
import com.cricketcraft.chisel.api.carving.ICarvingVariation;
import com.cricketcraft.chisel.client.render.RenderBlocksColumn;
/**
* Handles all default {@link ISubmapManager} behavior
*/
@SuppressWarnings("unchecked")
public enum TextureType {
// @formatter:off
TOPSIDE("top", "side") {
@Override
protected Object registerIcons(ICarvingVariation variation, String modName, String texturePath, IIconRegister register) {
return new IIcon[]{
register.registerIcon(modName + ":" + texturePath + "-side"),
register.registerIcon(modName + ":" + texturePath + "-top")
};
}
@Override
protected IIcon getIcon(ICarvingVariation variation, Object cachedObject, int side, int meta) {
IIcon[] icons = (IIcon[]) cachedObject;
return side > 1 ? icons[0] : icons[1];
}
},
TOPBOTSIDE("top", "bottom", "side"){
@Override
protected Object registerIcons(ICarvingVariation variation, String modName, String texturePath, IIconRegister register) {
return new IIcon[]{
register.registerIcon(modName + ":" + texturePath + "-side"),
register.registerIcon(modName + ":" + texturePath + "-bottom"),
register.registerIcon(modName + ":" + texturePath + "-top")
};
}
@Override
protected IIcon getIcon(ICarvingVariation variation, Object cachedObject, int side, int meta) {
IIcon[] icons = (IIcon[]) cachedObject;
return side > 1 ? icons[0] : icons[side + 1];
}
},
CTMV("ctmv", "top"){
@Override
protected Object registerIcons(ICarvingVariation variation, String modName, String texturePath, IIconRegister register) {
return Pair.of(new TextureSubmap(register.registerIcon(modName + ":" + texturePath + "-ctmv"), 2, 2), register.registerIcon(modName + ":" + texturePath + "-top"));
}
@Override
protected IIcon getIcon(ICarvingVariation variation, Object cachedObject, int side, int meta) {
Pair<TextureSubmap, IIcon> data = (Pair<TextureSubmap, IIcon>) cachedObject;
return side < 2 ? data.getRight() : data.getLeft().getSubIcon(0, 0);
}
@Override
protected IIcon getIcon(ICarvingVariation variation, Object cachedObject, IBlockAccess world, int x, int y, int z, int side, int meta) {
Pair<IIcon, TextureSubmap> data = (Pair<IIcon, TextureSubmap>) cachedObject;
if (side < 2)
return data.getLeft();
Block block = world.getBlock(x, y, z);
boolean topConnected = ctm.isConnected(world, x, y + 1, z, side, block, meta);
boolean botConnected = ctm.isConnected(world, x, y - 1, z, side, block, meta);
TextureSubmap map = data.getRight();
if (topConnected && botConnected)
return map.getSubIcon(0, 1);
if (topConnected && !botConnected)
return map.getSubIcon(1, 1);
if (!topConnected && botConnected)
return map.getSubIcon(1, 0);
return map.getSubIcon(0, 0);
}
@Override
protected RenderBlocks createRenderContext(RenderBlocks rendererOld, IBlockAccess world, Object cachedObject) {
RenderBlocksColumn ret = theRenderBlocksColumn;
Pair<IIcon, TextureSubmap> data = (Pair<IIcon, TextureSubmap>) cachedObject;
ret.blockAccess = world;
ret.renderMaxX = 1.0;
ret.renderMaxY = 1.0;
ret.renderMaxZ = 1.0;
ret.submap = data.getRight();
ret.iconTop = data.getLeft();
return ret;
}
},
CTMH("ctmh", "top"){
@Override
protected Object registerIcons(ICarvingVariation variation, String modName, String texturePath, IIconRegister register) {
return Pair.of(new TextureSubmap(register.registerIcon(modName + ":" + texturePath + "-ctmh"), 2, 2), register.registerIcon(modName + ":" + texturePath + "-top"));
}
@Override
protected IIcon getIcon(ICarvingVariation variation, Object cachedObject, int side, int meta) {
return CTMV.getIcon(variation, cachedObject, side, meta);
}
@Override
protected IIcon getIcon(ICarvingVariation variation, Object cachedObject, IBlockAccess world, int x, int y, int z, int side, int meta) {
Pair<IIcon, TextureSubmap> data = (Pair<IIcon, TextureSubmap>) cachedObject;
if (side < 2)
return data.getLeft();
Block block = ctm.getBlockOrFacade(world, x, y, z, side);
boolean p;
boolean n;
boolean reverse = side == 2 || side == 5;
if (side < 4) {
p = ctm.isConnected(world, x - 1, y, z, side, block, meta);
n = ctm.isConnected(world, x + 1, y, z, side, block, meta);
} else {
p = ctm.isConnected(world, x, y, z - 1, side, block, meta);
n = ctm.isConnected(world, x, y, z + 1, side, block, meta);
}
TextureSubmap map = data.getRight();
if (p && n)
return map.getSubIcon(1, 0);
else if (p)
return map.getSubIcon(reverse ? 0 : 1, 1);
else if (n)
return map.getSubIcon(reverse ? 0 : 1, 1);
return map.getSubIcon(0, 0);
}
},
V9("v9"){
@Override
protected Object registerIcons(ICarvingVariation variation, String modName, String texturePath, IIconRegister register) {
return new TextureSubmap(register.registerIcon(modName + ":" + texturePath + "-v9"), 3, 3);
}
@Override
protected IIcon getIcon(ICarvingVariation variation, Object cachedObject, int side, int meta) {
return ((TextureSubmap)cachedObject).getSubIcon(1, 1);
}
@Override
protected IIcon getIcon(ICarvingVariation variation, Object cachedObject, IBlockAccess world, int x, int y, int z, int side, int meta) {
int variationSize = (this == TextureType.V9) ? 3 : 2;
TextureSubmap map = (TextureSubmap) cachedObject;
int xModulus = x % variationSize;
int zModulus = z % variationSize;
//This ensures that blocks placed near 0,0 or it's axis' do not misbehave
int textureX = (xModulus < 0) ? (xModulus + variationSize) : xModulus;
int textureZ = (zModulus < 0) ? (zModulus + variationSize) : zModulus;
//Always invert the y index
int textureY = (variationSize - (y % variationSize) - 1);
if (side == 2 || side == 5) {
//For WEST, SOUTH reverse the indexes for both X and Z
textureX = (variationSize - textureX - 1);
textureZ = (variationSize - textureZ - 1);
} /*else if (side == 0) {
//For DOWN, reverse the indexes for only Z
textureZ = (variationSize - textureZ - 1);
}*/
int index;
if (side == 0 || side == 1) {
// DOWN || UP
index = textureX + textureZ * variationSize;
} else if (side == 2 || side == 3) {
// NORTH || SOUTH
index = textureX + textureY * variationSize;
} else {
// WEST || EAST
index = textureZ + textureY * variationSize;
}
return map.getSubIcon(index % variationSize, index / variationSize);
}
},
V4("v4"){
@Override
protected Object registerIcons(ICarvingVariation variation, String modName, String texturePath, IIconRegister register) {
return new TextureSubmap(register.registerIcon(modName + ":" + texturePath + "-v4"), 3, 3);
}
@Override
protected IIcon getIcon(ICarvingVariation variation, Object cachedObject, int side, int meta) {
return ((TextureSubmap)cachedObject).getSubIcon(0, 0);
}
@Override
protected IIcon getIcon(ICarvingVariation variation, Object cachedObject, IBlockAccess world, int x, int y, int z, int side, int meta) {
return V9.getIcon(variation, cachedObject, world, x, y, z, side, meta);
}
},
CTMX("", "ctm"){
@Override
protected Object registerIcons(ICarvingVariation variation, String modName, String texturePath, IIconRegister register) {
IIcon baseIcon = register.registerIcon(modName + ":" + texturePath);
return Triple.of(
baseIcon,
new TextureSubmap(register.registerIcon(modName + ":" + texturePath + "-ctm"), 4, 4),
new TextureSubmap(baseIcon, 2, 2)
);
}
@Override
protected IIcon getIcon(ICarvingVariation variation, Object cachedObject, int side, int meta) {
return ((Triple<IIcon, ?, ?>)cachedObject).getLeft();
}
@Override
protected RenderBlocks createRenderContext(RenderBlocks rendererOld, IBlockAccess world, Object cachedObject) {
RenderBlocksCTM ret = theRenderBlocksCTM;
Triple<?, TextureSubmap, TextureSubmap> data = (Triple<?, TextureSubmap, TextureSubmap>) cachedObject;
ret.blockAccess = world;
ret.renderMaxX = 1.0;
ret.renderMaxY = 1.0;
ret.renderMaxZ = 1.0;
ret.submap = data.getMiddle();
ret.submapSmall = data.getRight();
ret.rendererOld = rendererOld;
return ret;
}
},
R16("r16"){
@Override
protected Object registerIcons(ICarvingVariation variation, String modName, String texturePath, IIconRegister register) {
return new TextureSubmap(register.registerIcon(modName + ":" + texturePath + "-r16"), 4, 4);
}
@Override
protected IIcon getIcon(ICarvingVariation variation, Object cachedObject, int side, int meta) {
return V9.getIcon(variation, cachedObject, side, meta);
}
},
R9("r9"){
@Override
protected Object registerIcons(ICarvingVariation variation, String modName, String texturePath, IIconRegister register) {
return new TextureSubmap(register.registerIcon(modName + ":" + texturePath + "-r9"), 3, 3);
}
@Override
protected IIcon getIcon(ICarvingVariation variation, Object cachedObject, int side, int meta) {
return V9.getIcon(variation, cachedObject, side, meta);
}
@Override
protected IIcon getIcon(ICarvingVariation variation, Object cachedObject, IBlockAccess world, int x, int y, int z, int side, int meta) {
return R4.getIcon(variation, cachedObject, side, meta);
}
},
R4("r4"){
@Override
protected Object registerIcons(ICarvingVariation variation, String modName, String texturePath, IIconRegister register) {
return new TextureSubmap(register.registerIcon(modName + ":" + texturePath + "-r4"), 2, 2);
}
@Override
protected IIcon getIcon(ICarvingVariation variation, Object cachedObject, int side, int meta) {
return V4.getIcon(variation, cachedObject, side, meta);
}
@Override
protected IIcon getIcon(ICarvingVariation variation, Object cachedObject, IBlockAccess world, int x, int y, int z, int side, int meta) {
rand.setSeed(x + y + z + side);
rand.nextBoolean();
int size = this == TextureType.R4 ? 2 : 3;
return ((TextureSubmap)cachedObject).getSubIcon(rand.nextInt(size), rand.nextInt(size));
}
},
NORMAL,
CUSTOM;
private static final TextureType[] VALUES;
private static final CTM ctm = CTM.getInstance();
private static final Random rand = new Random();
private static final RenderBlocksCTM theRenderBlocksCTM = new RenderBlocksCTM();
private static final RenderBlocksColumn theRenderBlocksColumn = new RenderBlocksColumn();
private String[] suffixes;
static {
VALUES = ArrayUtils.subarray(values(), 0, values().length - 1);
}
private TextureType(String... suffixes) {
this.suffixes = suffixes.length == 0 ? new String[] { "" } : suffixes;
}
public ISubmapManager<RenderBlocks> createManagerFor(ICarvingVariation variation, String texturePath) {
return new SubmapManagerDefault(this, variation, texturePath);
}
public ISubmapManager<RenderBlocks> createManagerFor(ICarvingVariation variation, Block block, int meta) {
return new SubmapManagerExistingIcon(this, variation, block, meta);
}
protected Object registerIcons(ICarvingVariation variation, String modName, String texturePath, IIconRegister register) {
return register.registerIcon(modName + ":" + texturePath);
}
protected IIcon getIcon(ICarvingVariation variation, Object cachedObject, int side, int meta) {
return (IIcon) cachedObject;
}
protected IIcon getIcon(ICarvingVariation variation, Object cachedObject, IBlockAccess world, int x, int y, int z, int side, int meta) {
return getIcon(variation, cachedObject, side, meta);
}
protected RenderBlocks createRenderContext(RenderBlocks rendererOld, IBlockAccess world, Object cachedObject) {
return null;
}
public static TextureType getTypeFor(CarvableHelper inst, String modid, String path) {
if (path == null) {
return CUSTOM;
}
for (TextureType t : VALUES) {
boolean matches = true;
for (String s : t.suffixes) {
if (!exists(modid, path, s.isEmpty() ? s : "-" + s)) {
matches = false;
}
}
if (matches) {
return t;
}
}
return CUSTOM;
}
// This is ugly, but faster than class.getResource
private static boolean exists(String modid, String path, String postfix) {
ResourceLocation rl = new ResourceLocation(modid, "textures/blocks/" + path + postfix + ".png");
try {
Minecraft.getMinecraft().getResourceManager().getAllResources(rl);
return true;
} catch (Throwable t) {
return false;
}
}
private abstract static class SubmapManagerBase<T extends RenderBlocks> implements ISubmapManager<T> {
protected final TextureType type;
protected ICarvingVariation variation;
protected Object cachedObject;
private SubmapManagerBase(TextureType type, ICarvingVariation variation) {
this.type = type;
this.variation = variation;
}
@Override
public IIcon getIcon(int side, int meta) {
return type.getIcon(variation, cachedObject, side, meta);
}
@Override
public IIcon getIcon(IBlockAccess world, int x, int y, int z, int side) {
return type.getIcon(variation, cachedObject, world, x, y, z, side, world.getBlockMetadata(x, y, z));
}
@Override
public T createRenderContext(RenderBlocks rendererOld, IBlockAccess world) {
return (T) type.createRenderContext(rendererOld, world, cachedObject);
}
@Override
public void preRenderSide(RenderBlocks renderer, IBlockAccess world, int x, int y, int z, ForgeDirection side) {
}
@Override
public void postRenderSide(RenderBlocks renderer, IBlockAccess world, int x, int y, int z, ForgeDirection side) {
}
}
private static class SubmapManagerDefault extends SubmapManagerBase<RenderBlocks> {
private String texturePath;
private SubmapManagerDefault(TextureType type, ICarvingVariation variation, String texturePath) {
super(type, variation);
this.texturePath = texturePath;
}
@Override
public void registerIcons(String modName, Block block, IIconRegister register) {
cachedObject = type.registerIcons(variation, modName, texturePath, register);
}
}
private static class SubmapManagerExistingIcon extends SubmapManagerBase<RenderBlocks> {
private Block block;
private int meta;
private SubmapManagerExistingIcon(TextureType type, ICarvingVariation variation, Block block, int meta) {
super(type, variation);
this.block = block;
this.meta = meta;
}
@Override
public IIcon getIcon(int side, int meta) {
return block.getIcon(side, this.meta);
}
@Override
public IIcon getIcon(IBlockAccess world, int x, int y, int z, int side) {
return getIcon(side, world.getBlockMetadata(x, y, z));
}
@Override
public void registerIcons(String modName, Block block, IIconRegister register) {
}
}
}
@@ -0,0 +1,7 @@
@API(apiVersion = ChiselAPIProps.VERSION, owner = "Chisel", provides = "ChiselAPI|Rendering")
package com.cricketcraft.chisel.api.rendering;
import com.cricketcraft.chisel.api.ChiselAPIProps;
import cpw.mods.fml.common.API;