Render items inside item IItemRenderer.

BakeModelEvent.java

package code.elix_x.mods.armorsets.client.events;

import code.elix_x.mods.armorsets.client.renderer.ItemItemsSetModel;
import code.elix_x.mods.armorsets.proxy.ClientProxy;
import net.minecraftforge.client.event.ModelBakeEvent;
import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;

public class BakeModelEvent {

	@SubscribeEvent
	public void bake(ModelBakeEvent event){
		event.modelRegistry.putObject(ClientProxy.MODELLOCATION, new ItemItemsSetModel());
	}

}

ClientProxy.java

package code.elix_x.mods.armorsets.proxy;

import org.lwjgl.input.Keyboard;

import code.elix_x.excore.utils.proxy.IProxy;
import code.elix_x.mods.armorsets.ArmorSetsBase;
import code.elix_x.mods.armorsets.client.KeyBindingsCheckEvent;
import code.elix_x.mods.armorsets.client.events.BakeModelEvent;
import net.minecraft.client.resources.model.ModelResourceLocation;
import net.minecraft.client.settings.KeyBinding;
import net.minecraftforge.client.model.ModelLoader;
import net.minecraftforge.common.MinecraftForge;
import net.minecraftforge.fml.client.registry.ClientRegistry;
import net.minecraftforge.fml.common.FMLCommonHandler;
import net.minecraftforge.fml.common.Loader;
import net.minecraftforge.fml.common.event.FMLInitializationEvent;
import net.minecraftforge.fml.common.event.FMLPostInitializationEvent;
import net.minecraftforge.fml.common.event.FMLPreInitializationEvent;

public class ClientProxy implements IProxy {

	public static final ModelResourceLocation MODELLOCATION = new ModelResourceLocation("ItemsSet", "ItemsSet");

	public static KeyBinding armorSetKeyBinding = new KeyBinding("key.armorsets.armor", Keyboard.KEY_F, "category.armorsets");
	public static KeyBinding baublesSetKeyBinding = new KeyBinding("key.armorsets.baubles", Keyboard.KEY_G, "category.armorsets");
	public static KeyBinding armorBaublesSetKeyBinding = new KeyBinding("key.armorsets.armorbaubles", Keyboard.KEY_V, "category.armorsets");

	@Override
	public void preInit(FMLPreInitializationEvent event){
		ModelLoader.setCustomModelResourceLocation(ArmorSetsBase.itemArmorSet, 0, MODELLOCATION);
		if(Loader.isModLoaded("Baubles")){
			ModelLoader.setCustomModelResourceLocation(ArmorSetsBase.itemBaublesSet, 0, MODELLOCATION);
			ModelLoader.setCustomModelResourceLocation(ArmorSetsBase.itemArmorBaublesSet, 0, MODELLOCATION);
		}
		MinecraftForge.EVENT_BUS.register(new BakeModelEvent());
	}

	@Override
	public void init(FMLInitializationEvent event){
		ClientRegistry.registerKeyBinding(armorSetKeyBinding);
		ClientRegistry.registerKeyBinding(baublesSetKeyBinding);
		ClientRegistry.registerKeyBinding(armorBaublesSetKeyBinding);

		FMLCommonHandler.instance().bus().register(new KeyBindingsCheckEvent());
	}

	@Override
	public void postInit(FMLPostInitializationEvent event){

	}

}

ItemItemsList.java

package code.elix_x.mods.armorsets.items;

import code.elix_x.excore.utils.nbt.mbt.MBT;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;

public abstract class ItemItemsList extends Item {

	public static final MBT mbt = new MBT();

	private final String items = "items";

	private void fixTags(ItemStack itemstack){
		if(itemstack.getTagCompound() == null) itemstack.setTagCompound(new NBTTagCompound());
		if(!itemstack.getTagCompound().hasKey(this.items)) itemstack.getTagCompound().setTag(this.items, mbt.toNBT(new ItemStack[getMaxItems()]));
	}

	public abstract int getMaxItems();

	public ItemStack[] getItems(ItemStack itemstack){
		fixTags(itemstack);
		return mbt.fromNBT(itemstack.getTagCompound().getTag(this.items), ItemStack[].class);
	}

	public void setItems(ItemStack itemstack, ItemStack[] items){
		fixTags(itemstack);
		itemstack.getTagCompound().setTag(this.items, mbt.toNBT(items));
	}

	public ItemStack getItemInSlot(ItemStack itemstack, int slot){
		return getItems(itemstack)[slot];
	}

	public void setItemInSlot(ItemStack itemstack, ItemStack item, int slot){
		ItemStack[] items = getItems(itemstack);
		items[slot] = item;
		setItems(itemstack, items);
	}

}

ItemItemsSet.java

package code.elix_x.mods.armorsets.items;

import java.util.List;

import net.minecraft.client.gui.GuiScreen;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.ItemStack;
import net.minecraft.world.World;

public abstract class ItemItemsSet extends ItemItemsList {

	@Override
	public ItemStack onItemRightClick(ItemStack itemstack, World world, EntityPlayer player){
		if(!world.isRemote){
			player.inventory.markDirty();
			if(hasPlayerItems(player)){
				ItemStack newItemstack = new ItemStack(this);
				setItems(newItemstack, getPlayerItems(player));
				setPlayerItems(player, getItems(itemstack));
				return newItemstack;
			} else {
				setPlayerItems(player, getItems(itemstack));
				itemstack.stackSize = 0;
				return itemstack;
			}
		}
		return itemstack;
	}

	public abstract boolean hasPlayerItems(EntityPlayer player);

	public abstract ItemStack[] getPlayerItems(EntityPlayer player);

	public abstract void setPlayerItems(EntityPlayer player, ItemStack[] items);

	@Override
	public void addInformation(ItemStack itemstack, EntityPlayer player, List list, boolean debug){
		list.add("---");
		for(ItemStack item : getItems(itemstack)){
			if(item == null){
				list.add("");
			} else {
				if(!GuiScreen.isShiftKeyDown()){
					list.add(item.getDisplayName());
				} else {
					list.addAll(item.getTooltip(player, debug));
				}
			}
			list.add("---");
		}
	}

}

ItemItemsSetModel.java

package code.elix_x.mods.armorsets.client.renderer;

import java.util.List;

import javax.vecmath.Matrix4f;
import javax.vecmath.Vector3f;

import org.apache.commons.lang3.tuple.ImmutablePair;
import org.apache.commons.lang3.tuple.Pair;

import com.google.common.collect.ImmutableMap;

import code.elix_x.mods.armorsets.items.ItemItemsSet;
import net.minecraft.client.Minecraft;
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.DefaultVertexFormats;
import net.minecraft.client.renderer.vertex.VertexFormat;
import net.minecraft.client.resources.model.IBakedModel;
import net.minecraft.item.ItemStack;
import net.minecraft.util.EnumFacing;
import net.minecraftforge.client.model.IFlexibleBakedModel;
import net.minecraftforge.client.model.IPerspectiveAwareModel;
import net.minecraftforge.client.model.ISmartItemModel;
import net.minecraftforge.client.model.MultiModel;

public class ItemItemsSetModel implements ISmartItemModel {

	@Override
	public List<BakedQuad> getFaceQuads(EnumFacing facing){
		return null;
	}

	@Override
	public List<BakedQuad> getGeneralQuads(){
		return null;
	}

	@Override
	public boolean isAmbientOcclusion(){
		return false;
	}

	@Override
	public boolean isGui3d(){
		return false;
	}

	@Override
	public boolean isBuiltInRenderer(){
		return false;
	}

	@Override
	public TextureAtlasSprite getParticleTexture(){
		return null;
	}

	@Override
	public ItemCameraTransforms getItemCameraTransforms(){
		return null;
	}

	@Override
	public IBakedModel handleItemState(ItemStack itemstack){
		ItemStack[] items = ((ItemItemsSet) itemstack.getItem()).getItems(itemstack);
		final ImmutableMap.Builder<String, IFlexibleBakedModel> parts = ImmutableMap.builder();
		for(ItemStack item : items){
			if(item != null){
				IBakedModel model = Minecraft.getMinecraft().getRenderItem().getItemModelMesher().getItemModel(item);
				if(model instanceof IFlexibleBakedModel){
					parts.put(item.toString(), (IFlexibleBakedModel) model);
				} else {
					parts.put(items.toString(), new IFlexibleBakedModel.Wrapper(model, DefaultVertexFormats.ITEM));
				}
			}
		}
		return new IPerspectiveAwareModel(){
			
			@Override
			public boolean isGui3d(){
				return false;
			}
			
			@Override
			public boolean isBuiltInRenderer(){
				return false;
			}
			
			@Override
			public boolean isAmbientOcclusion(){
				return false;
			}
			
			@Override
			public TextureAtlasSprite getParticleTexture(){
				return null;
			}
			
			@Override
			public ItemCameraTransforms getItemCameraTransforms(){
				return null;
			}
			
			@Override
			public List<BakedQuad> getGeneralQuads(){
				return null;
			}
			
			@Override
			public List<BakedQuad> getFaceQuads(EnumFacing p_177551_1_){
				return null;
			}
			
			@Override
			public VertexFormat getFormat(){
				return null;
			}
			
			@Override
			public Pair<? extends IFlexibleBakedModel, Matrix4f> handlePerspective(TransformType transformType){
				Matrix4f matrix = new Matrix4f();
				if(transformType == TransformType.FIRST_PERSON){
					matrix.rotY(90);
					matrix.setTranslation(new Vector3f(0, 1, 0));
				} else {
					matrix.rotY(45);
				}
				return new ImmutablePair<IFlexibleBakedModel, Matrix4f>(new MultiModel.Baked(null, parts.build()), matrix);
			}
			
		};
	}

}

ItemItemsSetRenderer.java

public class ItemItemsSetRenderer implements IItemRenderer {

	public static final ItemRenderer itemRenderer = new ItemRenderer(Minecraft.getMinecraft());

	@Override
	public boolean handleRenderType(ItemStack itemstack, ItemRenderType type){
		return true;
	}

	@Override
	public boolean shouldUseRenderHelper(ItemRenderType type, ItemStack itemstack, ItemRendererHelper helper){
		return true;
	}

	@Override
	public void renderItem(ItemRenderType type, ItemStack itemstack, Object... data){
		ItemStack[] items = ((ItemItemsSet) itemstack.getItem()).getItems(itemstack);
		if(type == ItemRenderType.FIRST_PERSON_MAP){

		} else if(type == ItemRenderType.INVENTORY){
			GL11.glPushMatrix();
			GL11.glTranslated(2, 0.75, 1);
			GL11.glRotated(-45, 0.1, 0.2, -0.25);
			GL11.glScaled(1.1, 1.1, 1.1);
			for(ItemStack i : items){
				if(i != null){
					GL11.glPushMatrix();
					if(i.getItem().requiresMultipleRenderPasses()){
						for(int j = 0; j < i.getItem().getRenderPasses(i.getItemDamage()); j++){
							itemRenderer.renderItem(Minecraft.getMinecraft().thePlayer, i, j, type);
						}
					} else {
						itemRenderer.renderItem(Minecraft.getMinecraft().thePlayer, i, 0, type);
					}
					GL11.glPopMatrix();
					GL11.glTranslated(0, 0, 0.15);
				}
			}
			GL11.glPopMatrix();
		} else if(type == ItemRenderType.ENTITY){
			GL11.glPushMatrix();
			GL11.glTranslated(0.5, 0, -0.75);
			GL11.glRotated(25, 1, 0, 0);
			GL11.glScaled(0.75, 0.75, 0.75);
			for(ItemStack i : items){
				if(i != null){
					GL11.glPushMatrix();
					if(i.getItem().requiresMultipleRenderPasses()){
						for(int j = 0; j < i.getItem().getRenderPasses(i.getItemDamage()); j++){
							itemRenderer.renderItem(Minecraft.getMinecraft().thePlayer, i, j, type);
						}
					} else {
						itemRenderer.renderItem(Minecraft.getMinecraft().thePlayer, i, 0, type);
					}
					GL11.glPopMatrix();
					GL11.glTranslated(0, 0, 0.15);
				}
			}
			GL11.glPopMatrix();
		} else if(type == ItemRenderType.EQUIPPED){
			GL11.glPushMatrix();
			GL11.glTranslated(1, 0, 0.25);
			GL11.glRotated(45, 0, 0, 1);
			for(ItemStack i : items){
				if(i != null){
					GL11.glPushMatrix();
					if(i.getItem().requiresMultipleRenderPasses()){
						for(int j = 0; j < i.getItem().getRenderPasses(i.getItemDamage()); j++){
							itemRenderer.renderItem((EntityLivingBase) data[1], i, j, type);
						}
					} else {
						itemRenderer.renderItem((EntityLivingBase) data[1], i, 0, type);
					}
					GL11.glPopMatrix();
					GL11.glTranslated(0, 0, 0.15);
				}
			}
			GL11.glPopMatrix();
		} else {
			GL11.glPushMatrix();
			GL11.glTranslated(1, 0.5, 1);
			GL11.glRotated(-90, 0.2, 0.9, -0.25);
			for(ItemStack i : items){
				if(i != null){
					GL11.glPushMatrix();
					if(i.getItem().requiresMultipleRenderPasses()){
						for(int j = 0; j < i.getItem().getRenderPasses(i.getItemDamage()); j++){
							itemRenderer.renderItem((EntityLivingBase) data[1], i, j, type);
						}
					} else {
						itemRenderer.renderItem((EntityLivingBase) data[1], i, 0, type);
					}
					GL11.glPopMatrix();
					GL11.glTranslated(0, 0, 0.15);
				}
			}
			GL11.glPopMatrix();
		}
	}

}