[1.8.9] The difficult Simple way to have metadata textures for items

[Tschallacka]

In this tutorial i'm putting what I figured out what worked for me to get metadata item textures working again in an easy maintainable way for me.

 

It involves a couple of classes and an interface to be set up, but it's pretty simple.

In this tutorial I will however only show the neccesary code, not fully functional items etc... because I can't be bothered to strip all the support code form the one item I have.

 

First, we make a class to register all our items for rendering in. There are probaly better ways to do this, but this is what I used during my experimentations. Feel free to implement your own way, with or without singleton, static, dynamic, lists, whatever you fancy :-)

 

public class ItemRenderRegister {
/**
 * @var render Singleton of the render register that we use 
 **/
private static ItemRenderRegister render;
private ItemRenderRegister(){}

/**
 * Get the instance of the ItemRenderRegister
 * @return ItemRenderRegister instance
 */
public static ItemRenderRegister instance() {
	if(ItemRenderRegister.render == null) {
		ItemRenderRegister.render = new ItemRenderRegister();
	}
	return render;
}

/**
 * The method where we put all our items. You could possibly use
 * a list method here too where you get all your mod items from a list
 * Feel ree to use whatever method you choose, hardcoded, list, magic
 */
public static void registerItemRenderer() {

	// save the minor overhead of calling the function
	ItemRenderRegister inst = instance();

	// Register our item, let the rest do magic
	inst.reg(ItemLibrary.stripper);

    }	
/**
 * if the item is an instance of IItemVariantDetails
 * then let the item itself handle the registration of details
 * This is to keep code where it's logical(imho). 
 */
public void reg(Item item) {

	// self defining item? Let it do it's thing
	if(item instanceof IItemVariantDetails) {

		((IItemVariantDetails)item).registerItemVariants(this);

	}
	else {
		// Assume there is only one item with meta data 0
		reg(item,0);

	}
}
/**
 * Register item, look for JSON file based on registry name.
 * @param item The item to register
 * @param metadata The meta data to register it with
 */
public void reg(Item item, int metadata) {

    reg(item,metadata,item.getRegistryName());
    
}

/**
 * Register all our textures so forge knows them
 * @param item The item to register
 * @param metadata The meta data the texture applies to. 
 * @param file The name of the JSON file in "assets/MODID.toLowerCase()/models/items" without the .json extension 
 */
public void reg(Item item, int metadata, String file) {

	//Get our resource location up and running
	ModelResourceLocation location = new ModelResourceLocation(
			MagicCookies.MODID.toLowerCase() + ":" + file,
			"inventory"
			);

	// register the different variants(if any)
	ModelLoader.setCustomModelResourceLocation(item, metadata, location);
}
}

 

Then we also need the interface we check the instance of above here

 

public interface IItemVariantDetails {
/**<pre>
 * Method to register item variants
 * Usage to register items:                
 * <b>register.reg(this , metadata , String JSON_filename );</b>
 * <i>register.reg(this , 4 , "my_json_filename_without_extension" );</i>
 * for all different variants</PRE>
 */
public void registerItemVariants(ItemRenderRegister register);
}

 

public class StructureGenStripper extends Item implements IItemVariantDetails {

    public StructureGenStripper( String unLocalizedName ) {

        super();

        this.setUnlocalizedName( unLocalizedName );

        this.setCreativeTab( ModHooks.creativeTabMagicCookies );

        this.setMaxStackSize( 1 );

        this.setMaxDamage( 0 );

        this.setHasSubtypes( true );

    }
    .... // code to do magic for your item, do as you please
    @Override
        public void registerItemVariants(ItemRenderRegister register) {
        
        register.reg( this , 0 , "itemStripper"  );
        register.reg( this , 1 , "itemStripperair" );
        register.reg( this , 2 , "itemStripperSolid" );
        register.reg( this , 3 , "itemStripperPlacer" );
        register.reg( this , 4 , "itemStripperAssorted" );
        register.reg( this , 5 , "itemStripperUndo" );

}

 

Then in our client proxy we can call our rendere instantiation code, because graphics on the server side serve no purpose

 

    public class ClientProxy extends CommonProxy {

        public void registerRenderers() {

    	    ItemRenderRegister.registerItemRenderer();

         }
    }

 

And we can call the renderers in our main mod class in the pre init.

 

   @EventHandler
    public void preInit( FMLPreInitializationEvent event ) {

    	this.proxy.registerRenderers();

    }

 

So to recap. when all this code is all settled nicely in your mod, you only have to add the interface to your item, have eclipse add the method to your item and add your item to your ItemRenderRegister in the manner of your choosing and you're all set to go for your items and different icons.

 

How to set up icon jsons i'll leave up to you. That's a whole other can of worms. Just give them the exact same filename you define in the strings(case senstive)

 

If someone has a better way to do this, or more elegant, or if there's a path i'm unaware of, please, i wnat to know :-) This is just what I cobbled together in a night to make my life easier, but if there are better ways, or things i've overlooked, I do love knowing about it :-)

 

- Tsch

[coolAlias]

I did something very similar, but used Reflection to auto-register all my variants, and custom resource locations. (Note that the following code was tested in 1.8, so may not work perfectly anymore - I'll be finding that out soon enough, I expect).

 

Base item interface:

 

/**
* 
* Interface to improve encapsulation and allow automated registration of variants and renderers
*
*/
public interface IModItem {

/**
 * Returns an array of variant names to be used in {@link #registerVariants()} and possible {@link #registerRenderers(ItemModelMesher) registerRenderer()} 
 * Typical variant name is "mod_id:" plus the item's unlocalized name, minus any leading prefixes (e.g. 'item.')
 * @return Return null if there are no variants (e.g. standard generic item)
 */
String[] getVariants();

/**
 * Register any item variant names here using {@link ModelBakery#addVariantName}
 * This MUST be called during {@code FMLPreInitializationEvent}
 * 
 * Typical implementation taking advantage of {@link #getVariants()}:
 * 
 *	String[] variants = getVariants();
 *	if (variants != null) { // allows for alternate single variants, such as "minecraft:spawn_egg"
 *		ModelBakery.addVariantName(this, variants);
 *	}
 */
@SideOnly(Side.CLIENT)
void registerVariants();

/**
 * Register all of the Item's renderers here, including for any subtypes.
 * This MUST be called during {@code FMLInitializationEvent}
 * 
 * A default implementation to register an item with modid:itemname would be:
 *
 *	String name = getUnlocalizedName();
 *	name = YourMod.MODID + ":" + name.substring(name.lastIndexOf(".") + 1);
 *	mesher.register(this, 0, new ModelResourceLocation(name, "inventory"));
 */
@SideOnly(Side.CLIENT)
void registerRenderers(ItemModelMesher mesher);

}

 

 

Typical implementation of that interface:

 

/**
* 
* Provides generic implementations of IModItem methods that should work for most items.
*
*/
public class BaseModItem extends Item implements IModItem
{
public BaseModItem() {
	super();
}

/**
 * Default behavior returns NULL to not register any variants
 */
@Override
public String[] getVariants() {
	return null;
}

/**
 * Default implementation suggested by {@link IModItem#registerVariants()}
 */
@Override
@SideOnly(Side.CLIENT)
public void registerVariants() {
	String[] variants = getVariants();
	if (variants != null) {
		ModelBakery.addVariantName(this, variants);
	}
}

/**
 * Register all of this Item's renderers here, including for any subtypes.
 * Default behavior registers a single inventory-based mesher for each variant
 * returned by {@link #getVariants() getVariants}.
 * If no variants are available, "mod_id:" plus the item's unlocalized name is used.
 */
@Override
@SideOnly(Side.CLIENT)
public void registerRenderers(ItemModelMesher mesher) {
	String[] variants = getVariants();
	if (variants == null || variants.length < 1) {
		String name = getUnlocalizedName();
		variants = new String[]{ModInfo.ID + ":" + name.substring(name.lastIndexOf(".") + 1)};
	}
	for (int i = 0; i < variants.length; ++i) {
		mesher.register(this, i, new ModelResourceLocation(variants[i], "inventory"));
	}
}
}

 

 

My model swapper interface:

 

/**
* 
* Allows automating the {@link ModelBakeEvent} for both Blocks and Items
*
*/
@SuppressWarnings("deprecation")
public interface ISwapModel {

/**
 * Return the default resource locations used to retrieve this object from the model registry
 */
@SideOnly(Side.CLIENT)
Collection<ModelResourceLocation> getDefaultResources();

/**
 * Return the class used for the new model
 * The class must have a constructor that takes a single IBakedModel argument
 */
@SideOnly(Side.CLIENT)
Class<? extends IBakedModel> getNewModel();
}

 

 

ModelBakeEvent:

 

@SubscribeEvent
public void onBakeModel(ModelBakeEvent event) {
	for (ModelResourceLocation resource : ClientProxy.smartModels.keySet()) {
		Object object =  event.modelRegistry.getObject(resource);
		if (object instanceof IBakedModel) {
			Class<? extends IBakedModel> clazz = ClientProxy.smartModels.get(resource);
			try {
				IBakedModel customRender = clazz.getConstructor(IBakedModel.class).newInstance((IBakedModel) object);
				event.modelRegistry.putObject(resource, customRender);
				ZSSMain.logger.debug("Registered new renderer for resource " + resource + ": " + customRender.getClass().getSimpleName());
			} catch (NoSuchMethodException e) {
				ZSSMain.logger.warn("Failed to swap model: class " + clazz.getSimpleName() + " is missing a constructor that takes an IBakedModel");
			} catch (Exception e) {
				ZSSMain.logger.warn("Failed to swap model with exception: " + e.getMessage());
			}
		} else {
			ZSSMain.logger.warn("Resource is not a baked model! Failed resource: " + resource.toString());
		}
	}
}

 

 

In my ClientProxy:

 

/** Stores all models which need to be replaced during {@link ModelBakeEvent} */
@SuppressWarnings("deprecation")
public static final Map<ModelResourceLocation, Class<? extends net.minecraft.client.resources.model.IBakedModel>> smartModels = Maps.newHashMap();

/**
 * Automated variant and custom state mapper registration for blocks and items
 * Utilizes {@link IModItem#registerVariants()} and {@link ICustomStateMapper#getCustomStateMap()}
 * Call during FMLPreInitializationEvent after all Blocks and Items have been initialized
 */
private void registerVariants() {
	try {
		for (Field f: ZSSBlocks.class.getFields()) {
			if (Block.class.isAssignableFrom(f.getType())) {
				Block block = (Block) f.get(null);
				if (block != null) {
					if (block instanceof ICustomStateMapper) {
						ZSSMain.logger.debug("Setting custom state mapper for " + block.getUnlocalizedName());
						ModelLoader.setCustomStateMapper(block, ((ICustomStateMapper) block).getCustomStateMap());
					}
					String name = block.getUnlocalizedName();
					Item item = GameRegistry.findItem(ModInfo.ID, name.substring(name.lastIndexOf(".") + 1));
					if (item instanceof IModItem) {
						((IModItem) item).registerVariants();
					}
				}
			}
		}
	} catch(Exception e) {
		ZSSMain.logger.warn("Caught exception while registering block variants: " + e.toString());
		e.printStackTrace();
	}
	try {
		for (Field f: ZSSItems.class.getFields()) {
			if (Item.class.isAssignableFrom(f.getType())) {
				Item item = (Item) f.get(null);
				if (item instanceof IModItem) {
					((IModItem) item).registerVariants();
				}
			}
		}
	} catch(Exception e) {
		ZSSMain.logger.warn("Caught exception while registering item variants: " + e.toString());
		e.printStackTrace();
	}
}

/**
 * Automated block and item renderer registration using {@link IModItem#registerRenderers}
 */
private void registerRenderers() {
	try {
		for (Field f: ZSSBlocks.class.getFields()) {
			if (Block.class.isAssignableFrom(f.getType())) {
				Block block = (Block) f.get(null);
				if (block != null) {
					if (block instanceof ISpecialRenderer) {
						((ISpecialRenderer) block).registerSpecialRenderer();
					}
					if (block instanceof ISwapModel) {
						addModelToSwap((ISwapModel) block);
					}
					String name = block.getUnlocalizedName();
					Item item = GameRegistry.findItem(ModInfo.ID, name.substring(name.lastIndexOf(".") + 1));
					if (item instanceof IModItem) {
						((IModItem) item).registerRenderers(mc.getRenderItem().getItemModelMesher());
					}
					if (item instanceof ISwapModel) {
						addModelToSwap((ISwapModel) item);
					}
				}
			}
		}
	} catch(Exception e) {
		ZSSMain.logger.warn("Caught exception while registering block renderers: " + e.toString());
		e.printStackTrace();
	}
	try {
		for (Field f: ZSSItems.class.getFields()) {
			if (Item.class.isAssignableFrom(f.getType())) {
				Item item = (Item) f.get(null);
				if (item instanceof IModItem) {
					((IModItem) item).registerRenderers(mc.getRenderItem().getItemModelMesher());
				}
				if (item instanceof ISwapModel) {
					addModelToSwap((ISwapModel) item);
				}
			}
		}
	} catch(Exception e) {
		ZSSMain.logger.warn("Caught exception while registering item renderers: " + e.toString());
		e.printStackTrace();
	}
}

/**
 * Adds the model swap information to the map
 */
private void addModelToSwap(ISwapModel swap) {
	for (ModelResourceLocation resource : swap.getDefaultResources()) {
		if (smartModels.containsKey(resource)) {
			if (smartModels.get(resource) != swap.getNewModel()) {
				ZSSMain.logger.warn("Conflicting models for resource " + resource.toString() + ": models=[old: " + smartModels.get(resource).getSimpleName() + ", new: " + swap.getNewModel().getSimpleName());
			}
		} else {
			ZSSMain.logger.debug("Swapping model for " + resource.toString() + " to class " + swap.getNewModel().getSimpleName());
			smartModels.put(resource, swap.getNewModel());
		}
	}
}

 

 

I think that's about it. Makes the code really nice, imo, when a class is almost entirely self-descriptive; i.e. each class is responsible for itself, rather than expecting random lines of 'support' code all over the place. Here's an example of an Item actually using some of that stuff, and here's a Block.

 

P.S. There are some who disagree with using getUnlocalizedName in the ways that I have above; if you're one of those, feel free to use something else in your own code