Java 类net.minecraft.client.resources.model.ModelBakery 实例源码

项目：Minestrappolation-4 文件：ItemBricks2.java

public static void inventoryRender()
{
    Item itemBlockBrickVariants = GameRegistry.findItem(MReference.MODID, "bricks2");

    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:sandstone_brick");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:red_sandstone_brick");

    Item itemBlockVariants = GameRegistry.findItem(MReference.MODID, "bricks2");
    ItemBrickTypes2[] aenumtype = ItemBrickTypes2.values();
    int i = aenumtype.length;

    for (int j = 0; j < i; ++j)
    {
        ItemBrickTypes2 enumtype = aenumtype[j];
        ModelResourceLocation itemModelResourceLocation = new ModelResourceLocation(MReference.MODID + ":"
                                                                                        + enumtype
                                                                                              .getUnlocalizedName()
                                                                                        + "_brick", "inventory");
        Minecraft.getMinecraft().getRenderItem().getItemModelMesher()
                 .register(itemBlockVariants, enumtype.getMetadata(), itemModelResourceLocation);
    }
}

项目：Minestrappolation-4 文件：ItemUpgradeChips.java

public static void inventoryRender()
{
    Item itemBlockBrickVariants = GameRegistry.findItem(MReference.MODID, "chips");

    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:preserver_chips");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:collision_chips");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:inversion_chips");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:selfsufficient_chips");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:placer_chips");

    Item itemBlockVariants = GameRegistry.findItem(MReference.MODID, "chips");
    ItemChipTypes[] aenumtype = ItemChipTypes.values();
    int i = aenumtype.length;

    for (int j = 0; j < i; ++j)
    {
        ItemChipTypes enumtype = aenumtype[j];
        ModelResourceLocation itemModelResourceLocation = new ModelResourceLocation(MReference.MODID + ":"
                                                                                        + enumtype
                                                                                              .getUnlocalizedName()
                                                                                        + "_chips", "inventory");
        Minecraft.getMinecraft().getRenderItem().getItemModelMesher()
                 .register(itemBlockVariants, enumtype.getMetadata(), itemModelResourceLocation);
    }
}

项目：Minestrappolation-4 文件：MBlockPlanks.java

public static void inventoryRender()
{
    Item itemBlockBrickVariants = GameRegistry.findItem(MReference.MODID, "ministrapp_planks");

    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:redwood_planks");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:frozen_oak_planks");

    Item itemBlockVariants = GameRegistry.findItem(MReference.MODID, "ministrapp_planks");
    MWoodType[] aenumtype = MWoodType.values();
    int i = aenumtype.length;

    for (int j = 0; j < i; ++j)
    {
        MWoodType enumtype = aenumtype[j];
        ModelResourceLocation itemModelResourceLocation = new ModelResourceLocation(MReference.MODID + ":"
                                                                                        + enumtype
                                                                                              .getUnlocalizedName()
                                                                                        + "_planks", "inventory");
        Minecraft.getMinecraft().getRenderItem().getItemModelMesher()
                 .register(itemBlockVariants, enumtype.getMetadata(), itemModelResourceLocation);
    }
}

项目：Minestrappolation-4 文件：MBlockLeaves.java

public static void inventoryRender()
{
    Item itemBlockBrickVariants = GameRegistry.findItem(MReference.MODID, "ministrapp_leaves");

    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:redwood_leaves");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:frozen_oak_leaves");

    Item itemBlockVariants = GameRegistry.findItem(MReference.MODID, "ministrapp_leaves");
    MWoodType[] aenumtype = MWoodType.values();
    int i = aenumtype.length;

    for (int j = 0; j < i; ++j)
    {
        MWoodType enumtype = aenumtype[j];
        ModelResourceLocation itemModelResourceLocation = new ModelResourceLocation(MReference.MODID + ":"
                                                                                        + enumtype
                                                                                              .getUnlocalizedName()
                                                                                        + "_leaves", "inventory");
        Minecraft.getMinecraft().getRenderItem().getItemModelMesher()
                 .register(itemBlockVariants, enumtype.getMetadata(), itemModelResourceLocation);
    }
}

项目：Minestrappolation-4 文件：MBlockSapling.java

public static void inventoryRender()
{
    Item itemBlockBrickVariants = GameRegistry.findItem(MReference.MODID, "ministrapp_sapling");

    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:redwood_sapling");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:frozen_oak_sapling");

    Item itemBlockVariants = GameRegistry.findItem(MReference.MODID, "ministrapp_sapling");
    MWoodType[] aenumtype = MWoodType.values();
    int i = aenumtype.length;

    for (int j = 0; j < i; ++j)
    {
        MWoodType enumtype = aenumtype[j];
        ModelResourceLocation itemModelResourceLocation = new ModelResourceLocation(MReference.MODID + ":"
                                                                                        + enumtype
                                                                                              .getUnlocalizedName()
                                                                                        + "_sapling", "inventory");
        Minecraft.getMinecraft().getRenderItem().getItemModelMesher()
                 .register(itemBlockVariants, enumtype.getMetadata(), itemModelResourceLocation);
    }
}

项目：Minestrappolation-4 文件：BlockVirtianSoil.java

public static void inventoryRender()
{
    Item item = GameRegistry.findItem(MReference.MODID, "virtian_soil");

    ModelBakery.addVariantName(item, "ministrapp:virtian_soil_dirt");
    ModelBakery.addVariantName(item, "ministrapp:virtian_soil_coarse_dirt");
    ModelBakery.addVariantName(item, "ministrapp:virtian_soil_podzol");

    Item itemBlockVariants = GameRegistry.findItem(MReference.MODID, "virtian_soil");
    DirtType[] aenumtype = BlockDirt.DirtType.values();
    int i = aenumtype.length;

    for (int j = 0; j < i; ++j)
    {
        BlockDirt.DirtType enumtype = aenumtype[j];
        ModelResourceLocation itemModelResourceLocation = new ModelResourceLocation(MReference.MODID + ":"
                                                                                        + "virtian_soil_" + enumtype
                                                                                                                .getName(),
                                                                                    "inventory");
        Minecraft.getMinecraft().getRenderItem().getItemModelMesher()
                 .register(itemBlockVariants, enumtype.getMetadata(), itemModelResourceLocation);
    }
}

项目：Minestrappolation-4 文件：BlockCarvedPumpkin.java

public static void inventoryRender(String type)
{
    Item itemBlockpVariants = GameRegistry.findItem(MReference.MODID, "pumpkin_minestrapp_" + type);

    ModelBakery.addVariantName(itemBlockpVariants, "ministrapp:simple_carved_" + type);
    ModelBakery.addVariantName(itemBlockpVariants, "ministrapp:average_carved_" + type);
    ModelBakery.addVariantName(itemBlockpVariants, "ministrapp:complex_carved_" + type);

    Item itemBlockVariants = GameRegistry.findItem(MReference.MODID, "pumpkin_minestrapp_" + type);
    MPumpkinType[] aenumtype = MPumpkinType.values();
    int i = aenumtype.length;

    for (int j = 0; j < i; ++j)
    {
        MPumpkinType enumtype = aenumtype[j];
        ModelResourceLocation itemModelResourceLocation = new ModelResourceLocation(MReference.MODID + ":"
                                                                                        + enumtype
                                                                                              .getUnlocalizedName()
                                                                                        + "_carved_" + type,
                                                                                    "inventory");
        Minecraft.getMinecraft().getRenderItem().getItemModelMesher()
                 .register(itemBlockVariants, enumtype.getMetadata(), itemModelResourceLocation);
    }
}

项目：Minestrappolation-4 文件：BlockMSand.java

public static void inventoryRender()
{
    Item item = GameRegistry.findItem(MReference.MODID, "cold_sand");

    ModelBakery.addVariantName(item, "ministrapp:cold_sand");
    ModelBakery.addVariantName(item, "ministrapp:cold_red_sand");

    Item itemBlockVariants = GameRegistry.findItem(MReference.MODID, "cold_sand");
    EnumType[] aenumtype = BlockSand.EnumType.values();
    int i = aenumtype.length;

    for (int j = 0; j < i; ++j)
    {
        BlockSand.EnumType enumtype = aenumtype[j];
        ModelResourceLocation itemModelResourceLocation = new ModelResourceLocation(MReference.MODID + ":" + "cold_"
                                                                                        + enumtype.getName(),
                                                                                    "inventory");
        Minecraft.getMinecraft().getRenderItem().getItemModelMesher()
                 .register(itemBlockVariants, enumtype.getMetadata(), itemModelResourceLocation);
    }
}

项目：Minestrappolation-4 文件：MBlockLog.java

public static void inventoryRender()
{
    Item itemBlockBrickVariants = GameRegistry.findItem(MReference.MODID, "ministrapp_log");

    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:redwood_log");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:frozen_oak_log");

    Item itemBlockVariants = GameRegistry.findItem(MReference.MODID, "ministrapp_log");
    MWoodType[] aenumtype = MWoodType.values();
    int i = aenumtype.length;

    for (int j = 0; j < i; ++j)
    {
        MWoodType enumtype = aenumtype[j];
        ModelResourceLocation itemModelResourceLocation = new ModelResourceLocation(MReference.MODID + ":"
                                                                                        + enumtype
                                                                                              .getUnlocalizedName()
                                                                                        + "_log", "inventory");
        Minecraft.getMinecraft().getRenderItem().getItemModelMesher()
                 .register(itemBlockVariants, enumtype.getMetadata(), itemModelResourceLocation);
    }
}

项目：Minestrappolation-4 文件：MFluid.java

@SideOnly(Side.CLIENT)
public static void buildRenderFor(Block block, String name)
{
    final ModelResourceLocation fluidLocation = new ModelResourceLocation(MReference.MODID + ":" + name, "fluid");
    Item fluid = Item.getItemFromBlock(block);
    ModelBakery.addVariantName(fluid);
    ModelLoader.setCustomMeshDefinition(fluid, new ItemMeshDefinition()
    {
        @Override
        public ModelResourceLocation getModelLocation(ItemStack stack)
        {
            return fluidLocation;
        }
    });
    ModelLoader.setCustomStateMapper(block, new StateMapperBase()
    {
        @Override
        protected ModelResourceLocation getModelResourceLocation(IBlockState state)
        {
            return fluidLocation;
        }
    });
}

项目：MineChess 文件：ClientProxyMineChess.java

@Override
public void registerRenders(){
    super.registerRenders();
    RenderingRegistry.registerEntityRenderingHandler(EntityRook.class, new RenderChessPiece(new ModelRook(), 0.3F));
    RenderingRegistry.registerEntityRenderingHandler(EntityKing.class, new RenderChessPiece(new ModelKing(), 0.3F));
    RenderingRegistry.registerEntityRenderingHandler(EntityPawn.class, new RenderChessPiece(new ModelPawn(), 0.3F));
    RenderingRegistry.registerEntityRenderingHandler(EntityKnight.class, new RenderChessPiece(new ModelKnight(), 0.3F));
    RenderingRegistry.registerEntityRenderingHandler(EntityQueen.class, new RenderChessPiece(new ModelQueen(), 0.3F));
    RenderingRegistry.registerEntityRenderingHandler(EntityBishop.class, new RenderChessPiece(new ModelBishop(), 0.3F));
    RenderingRegistry.registerEntityRenderingHandler(EntityPickyXPOrb.class, new RenderXPOrb(Minecraft.getMinecraft().getRenderManager()));
    MinecraftForge.EVENT_BUS.register(new MineChessDrawBlockHighlightHandler());

    String[] names = new String[5];
    for(int i = 0; i < 5; i++) {
        String name = "chessmod:" + new ItemStack(MineChess.itemPieceMover, 1, i).getUnlocalizedName().substring(5);
        names[i] = name;
        Minecraft.getMinecraft().getRenderItem().getItemModelMesher().register(MineChess.itemPieceMover, i, new ModelResourceLocation(name, "inventory"));
    }
    ModelBakery.addVariantName(MineChess.itemPieceMover, names);
}

项目：AuraMod 文件：ItemAuraOrb.java

public static void registerVariants()
{
    String[] variantNames = new String[metaNames.length];
    for (int i = 0; i < metaNames.length; i++)
    {
        variantNames[i] = AuraMod.MODID + ":" + getNameFromDamage(i);
    }
    ModelBakery.addVariantName(AuraMod.orb, variantNames);
}

项目：AuraMod 文件：BlockAuraStone.java

public static void registerVariants()
{
    String[] variants = new String[values().length];

    for (int i = 0; i < values().length; i++)
    {
        variants[i] = values()[i].getResouceLocation();
    }

    ModelBakery.addVariantName(Item.getItemFromBlock(AuraMod.AuraStone), variants);
}

项目：SimplySledgehammers 文件：ModRendering.java

private static void initOreChunks(RenderItem renderItem) {
    ModelBakery.registerItemVariants(
            ModItems.oreChunk,
            new ResourceLocation(Reference.MODID + ":ore_chunk_iron"),
            new ResourceLocation(Reference.MODID + ":ore_chunk_gold"),
            new ResourceLocation(Reference.MODID + ":ore_chunk_copper"),
            new ResourceLocation(Reference.MODID + ":ore_chunk_tin"),
            new ResourceLocation(Reference.MODID + ":ore_chunk_nickel"),
            new ResourceLocation(Reference.MODID + ":ore_chunk_lead"),
            new ResourceLocation(Reference.MODID + ":ore_chunk_silver"));

    renderItem.getItemModelMesher().register(
            ModItems.oreChunk,
            ItemOreChunk.IRON_DAMAGE,
            new ModelResourceLocation(Reference.MODID + ":ore_chunk_iron", "inventory"));
    renderItem.getItemModelMesher().register(
            ModItems.oreChunk,
            ItemOreChunk.GOLD_DAMAGE,
            new ModelResourceLocation(Reference.MODID + ":ore_chunk_gold", "inventory"));
    renderItem.getItemModelMesher().register(
            ModItems.oreChunk,
            ItemOreChunk.COPPER_DAMAGE,
            new ModelResourceLocation(Reference.MODID + ":ore_chunk_copper", "inventory"));
    renderItem.getItemModelMesher().register(
            ModItems.oreChunk,
            ItemOreChunk.TIN_DAMAGE,
            new ModelResourceLocation(Reference.MODID + ":ore_chunk_tin", "inventory"));
    renderItem.getItemModelMesher().register(
            ModItems.oreChunk,
            ItemOreChunk.NICKEL_DAMAGE,
            new ModelResourceLocation(Reference.MODID + ":ore_chunk_nickel", "inventory"));
    renderItem.getItemModelMesher().register(
            ModItems.oreChunk,
            ItemOreChunk.LEAD_DAMAGE,
            new ModelResourceLocation(Reference.MODID + ":ore_chunk_lead", "inventory"));
    renderItem.getItemModelMesher().register(
            ModItems.oreChunk,
            ItemOreChunk.SILVER_DAMAGE,
            new ModelResourceLocation(Reference.MODID + ":ore_chunk_silver", "inventory"));
}

项目：SimplySledgehammers 文件：ModRendering.java

private static void initUnsmeltedIngots(RenderItem renderItem) {
    ModelBakery.registerItemVariants(
            ModItems.unsmeltedIngot,
            new ResourceLocation(Reference.MODID + ":unsmelted_ingot_iron"),
            new ResourceLocation(Reference.MODID + ":unsmelted_ingot_gold"),
            new ResourceLocation(Reference.MODID + ":unsmelted_ingot_copper"),
            new ResourceLocation(Reference.MODID + ":unsmelted_ingot_tin"),
            new ResourceLocation(Reference.MODID + ":unsmelted_ingot_nickel"),
            new ResourceLocation(Reference.MODID + ":unsmelted_ingot_lead"),
            new ResourceLocation(Reference.MODID + ":unsmelted_ingot_silver"));
    renderItem.getItemModelMesher().register(
            ModItems.unsmeltedIngot,
            ItemUnsmeltedIngot.IRON_DAMAGE,
            new ModelResourceLocation(Reference.MODID + ":unsmelted_ingot_iron", "inventory"));
    renderItem.getItemModelMesher().register(
            ModItems.unsmeltedIngot,
            ItemUnsmeltedIngot.GOLD_DAMAGE,
            new ModelResourceLocation(Reference.MODID + ":unsmelted_ingot_gold", "inventory"));
    renderItem.getItemModelMesher().register(
            ModItems.unsmeltedIngot,
            ItemUnsmeltedIngot.COPPER_DAMAGE,
            new ModelResourceLocation(Reference.MODID + ":unsmelted_ingot_copper", "inventory"));
    renderItem.getItemModelMesher().register(
            ModItems.unsmeltedIngot,
            ItemUnsmeltedIngot.TIN_DAMAGE,
            new ModelResourceLocation(Reference.MODID + ":unsmelted_ingot_tin", "inventory"));
    renderItem.getItemModelMesher().register(
            ModItems.unsmeltedIngot,
            ItemUnsmeltedIngot.NICKEL_DAMAGE,
            new ModelResourceLocation(Reference.MODID + ":unsmelted_ingot_nickel", "inventory"));
    renderItem.getItemModelMesher().register(
            ModItems.unsmeltedIngot,
            ItemUnsmeltedIngot.LEAD_DAMAGE,
            new ModelResourceLocation(Reference.MODID + ":unsmelted_ingot_lead", "inventory"));
    renderItem.getItemModelMesher().register(
            ModItems.unsmeltedIngot,
            ItemUnsmeltedIngot.SILVER_DAMAGE,
            new ModelResourceLocation(Reference.MODID + ":unsmelted_ingot_silver", "inventory"));
}

项目：Factorization 文件：FactorizationClientProxy.java

private static void modelForMetadata(Block block, String... parts) {
    Item item = DataUtil.getItem(block);
    for (int md = 0; md < parts.length; md++) {
        String name = parts[md];
        name = "factorization:" + name;
        parts[md] = name;
        ModelResourceLocation modelName = new ModelResourceLocation(name, "inventory");
        ModelLoader.setCustomModelResourceLocation(item, md, modelName);
    }
    ModelBakery.addVariantName(item, parts);
}

项目：Factorization 文件：FactorizationClientProxy.java

private static void modelForMetadataExplicit(Block block, Object... parts) {
    ArrayList<String> found = new ArrayList<String>();
    Item item = DataUtil.getItem(block);
    if (parts.length % 2 != 0) throw new IllegalArgumentException("Invalid argument format");
    for (int i = 0; i < parts.length; i += 2) {
        int md = (Integer) parts[i];
        String name = (String) parts[i + 1];
        name = "factorization:" + name;
        parts[i + 1] = name;
        ModelLoader.setCustomModelResourceLocation(item, md, new ModelResourceLocation(name, "inventory"));
        found.add(name);
    }
    ModelBakery.addVariantName(item, found.toArray(new String[found.size()]));
}

项目：MissingTextures 文件：StartupClientOnly.java

public static void preInitClientOnly()
  {
//    need to add the variants to the bakery so it knows what models are available for rendering the different subtypes
    ModelBakery.addVariantName(StartupCommon.itemMT52,  "missingtextures:mt52_itemmodel_1"
//            , "missingtextures:mt52_itemmodel_2"
    );
  }

项目：MissingTextures 文件：StartupClientOnly.java

public static void preInitClientOnly()
{
  Item itemBlockVariants = GameRegistry.findItem("missingtextures", "mbe03_block_variants");

  // need to add the variants to the bakery so it knows what models are available for rendering the different subtypes
  ModelBakery.addVariantName(itemBlockVariants, "missingtextures:mbe03_block_variants_blue",
          "missingtextures:mbe03_block_variants_green",
          "missingtextures:mbe03_block_variants_red",
          "missingtextures:mbe03_block_variants_yellow");
}

项目：MissingTextures 文件：StartupClientOnly.java

public static void preInitClientOnly()
  {
//    need to add the variants to the bakery so it knows what models are available for rendering the different subtypes
    ModelBakery.addVariantName(StartupCommon.itemVariants,  "missingtextures:mbe11_item_variants_0pc",
            "missingtextures:mbe11_item_variants_25pc",
            "missingtextures:mbe11_item_variants_50pc",
            "missingtextures:mbe11_item_variants_75pc",
            "missingtextures:mbe11_item_variants_100pc"
    );
  }

项目：CivCraft 文件：ItemTechnology.java

@Override
public void initModel() {
    String mesherName = CivCraft.instance.meta.modId + ":" + name + "_";
    String[] names = new String[] { mesherName + "none", mesherName + "some", mesherName + "all" };
    ItemModelMesher mesher = Minecraft.getMinecraft().getRenderItem().getItemModelMesher();
    for (int i = 0; i < 3; i++)
        mesher.register(this, i, new ModelResourceLocation(names[i], "inventory"));
    ModelBakery.addVariantName(this, names);
}

项目：ExoticPower 文件：ClientProxy.java

public void registerItemModels() {
    for (Item item : EPItems.itemList) {
        Minecraft.getMinecraft().getRenderItem().getItemModelMesher().register(item,
                0, new ModelResourceLocation("ExoticPower:" + item.getUnlocalizedName(), "inventory"));
        ModelBakery.addVariantName(item, "ExoticPower:" + item.getUnlocalizedName());
    }
}

项目：DimsumCraft 文件：ClientProxy.java

@Override
public void registerItemModels() {
    for (Item item : ModItems.itemList) {
        Minecraft.getMinecraft().getRenderItem().getItemModelMesher().register(item, 0, new ModelResourceLocation("dimsumcraft:" + item.getUnlocalizedName(), "inventory"));
        ModelBakery.addVariantName(item, "dimsumcraft:" + item.getUnlocalizedName());
    }
}

项目：FutureCraft 文件：StartupClientOnly.java

private static void registerMetaItemRendering(String name, String... modelNames) {
    Item item = GameRegistry.findItem(FutureCraft.MODID, name);
    ItemModelMesher mesher = Minecraft.getMinecraft().getRenderItem().getItemModelMesher();
    String[] newModelNames = new String[modelNames.length];
    for (int i = 0; i < modelNames.length; i++) {
        newModelNames[i] = FutureCraft.MODID + ":" + modelNames[i];
    }

    ModelBakery.addVariantName(item, newModelNames);

    for (int i = 0; i < modelNames.length; i++) {
        mesher.register(item, i, new ModelResourceLocation(FutureCraft.MODID + ":" + modelNames[i], "inventory"));
    }
}

项目：Minestrappolation-4 文件：ItemChunk.java

public static void inventoryRender()
{
    Item itemBlockBrickVariants = GameRegistry.findItem(MReference.MODID, "chunks");

    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:stone_chunk");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:red_rock_chunk");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:coldstone_chunk");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:icestone_chunk");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:oceanstone_chunk");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:copper_chunk");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:gold_chunk");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:tin_chunk");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:iron_chunk");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:torite_chunk");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:titanium_chunk");

    Item itemBlockVariants = GameRegistry.findItem(MReference.MODID, "chunks");
    MItemChunkTypes[] aenumtype = MItemChunkTypes.values();
    int i = aenumtype.length;

    for (int j = 0; j < i; ++j)
    {
        MItemChunkTypes enumtype = aenumtype[j];
        ModelResourceLocation itemModelResourceLocation = new ModelResourceLocation(MReference.MODID + ":"
                                                                                        + enumtype
                                                                                              .getUnlocalizedName()
                                                                                        + "_chunk", "inventory");
        Minecraft.getMinecraft().getRenderItem().getItemModelMesher()
                 .register(itemBlockVariants, enumtype.getMetadata(), itemModelResourceLocation);
    }
}

项目：Minestrappolation-4 文件：ItemBricks.java

public static void inventoryRender()
{
    Item itemBlockBrickVariants = GameRegistry.findItem(MReference.MODID, "bricks");

    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:stone_brick");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:deepstone_brick");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:red_rock_brick");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:deep_red_rock_brick");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:coldstone_brick");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:deep_coldstone_brick");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:icestone_brick");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:glacierrock_brick");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:oceanstone_brick");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:pressurized_oceanstone_brick");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:slate_brick");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:granite_brick");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:diorite_brick");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:andesite_brick");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:obsidian_brick");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:flint_brick");

    Item itemBlockVariants = GameRegistry.findItem(MReference.MODID, "bricks");
    ItemBrickTypes[] aenumtype = ItemBrickTypes.values();
    int i = aenumtype.length;

    for (int j = 0; j < i; ++j)
    {
        ItemBrickTypes enumtype = aenumtype[j];
        ModelResourceLocation itemModelResourceLocation = new ModelResourceLocation(MReference.MODID + ":"
                                                                                        + enumtype
                                                                                              .getUnlocalizedName()
                                                                                        + "_brick", "inventory");
        Minecraft.getMinecraft().getRenderItem().getItemModelMesher()
                 .register(itemBlockVariants, enumtype.getMetadata(), itemModelResourceLocation);
    }
}

项目：Minestrappolation-4 文件：BlockBiomeBricks.java

public static void inventoryRender()
{
    Item itemBlockBrickVariants = GameRegistry.findItem(MReference.MODID, "biome_bricks");

    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:deepstone_bricks");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:coldstone_bricks");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:icestone_bricks");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:glacierrock_bricks");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:deep_coldstone_bricks");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:red_rock_bricks");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:deep_redrock_bricks");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:oceanstone_bricks");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:pressurized_oceanstone_bricks");

    Item itemBlockVariants = GameRegistry.findItem(MReference.MODID, "biome_bricks");
    MStoneType[] aenumtype = MStoneType.values();
    int i = aenumtype.length;

    for (int j = 0; j < i; ++j)
    {
        MStoneType enumtype = aenumtype[j];
        ModelResourceLocation itemModelResourceLocation = new ModelResourceLocation(MReference.MODID + ":"
                                                                                        + enumtype
                                                                                              .getUnlocalizedName()
                                                                                        + "_bricks", "inventory");
        Minecraft.getMinecraft().getRenderItem().getItemModelMesher()
                 .register(itemBlockVariants, enumtype.getMetadata(), itemModelResourceLocation);
    }
}

项目：Minestrappolation-4 文件：BlockBiomeStones.java

public static void inventoryRender()
{
    Item item = GameRegistry.findItem(MReference.MODID, "biome_stone");

    ModelBakery.addVariantName(item, "ministrapp:deepstone");
    ModelBakery.addVariantName(item, "ministrapp:coldstone");
    ModelBakery.addVariantName(item, "ministrapp:icestone");
    ModelBakery.addVariantName(item, "ministrapp:glacierrock");
    ModelBakery.addVariantName(item, "ministrapp:deep_coldstone");
    ModelBakery.addVariantName(item, "ministrapp:red_rock");
    ModelBakery.addVariantName(item, "ministrapp:deep_redrock");
    ModelBakery.addVariantName(item, "ministrapp:oceanstone");
    ModelBakery.addVariantName(item, "ministrapp:pressurized_oceanstone");

    Item itemBlockVariants = GameRegistry.findItem(MReference.MODID, "biome_stone");
    MStoneType[] aenumtype = MStoneType.values();
    int i = aenumtype.length;

    for (int j = 0; j < i; ++j)
    {
        MStoneType enumtype = aenumtype[j];
        ModelResourceLocation itemModelResourceLocation = new ModelResourceLocation(MReference.MODID + ":"
                                                                                        + enumtype
                                                                                              .getUnlocalizedName(),
                                                                                    "inventory");
        Minecraft.getMinecraft().getRenderItem().getItemModelMesher()
                 .register(itemBlockVariants, enumtype.getMetadata(), itemModelResourceLocation);
    }
}

项目：Minestrappolation-4 文件：BlockBiomeGold.java

public static void inventoryRender()
{
    Item itemBlockBrickVariants = GameRegistry.findItem(MReference.MODID, "biome_gold");

    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:deepstone_gold");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:coldstone_gold");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:icestone_gold");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:glacierrock_gold");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:deep_coldstone_gold");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:red_rock_gold");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:deep_redrock_gold");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:oceanstone_gold");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:pressurized_oceanstone_gold");

    Item itemBlockVariants = GameRegistry.findItem(MReference.MODID, "biome_gold");
    MStoneType[] aenumtype = MStoneType.values();
    int i = aenumtype.length;

    for (int j = 0; j < i; ++j)
    {
        MStoneType enumtype = aenumtype[j];
        ModelResourceLocation itemModelResourceLocation = new ModelResourceLocation(MReference.MODID + ":"
                                                                                        + enumtype
                                                                                              .getUnlocalizedName()
                                                                                        + "_gold", "inventory");
        Minecraft.getMinecraft().getRenderItem().getItemModelMesher()
                 .register(itemBlockVariants, enumtype.getMetadata(), itemModelResourceLocation);
    }
}

项目：Minestrappolation-4 文件：BlockBiomeTitanium.java

public static void inventoryRender()
{
    Item itemBlockBrickVariants = GameRegistry.findItem(MReference.MODID, "biome_titanium");

    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:deepstone_titanium");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:coldstone_titanium");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:icestone_titanium");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:glacierrock_titanium");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:deep_coldstone_titanium");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:red_rock_titanium");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:deep_redrock_titanium");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:oceanstone_titanium");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:pressurized_oceanstone_titanium");

    Item itemBlockVariants = GameRegistry.findItem(MReference.MODID, "biome_titanium");
    MStoneType[] aenumtype = MStoneType.values();
    int i = aenumtype.length;

    for (int j = 0; j < i; ++j)
    {
        MStoneType enumtype = aenumtype[j];
        ModelResourceLocation itemModelResourceLocation = new ModelResourceLocation(MReference.MODID + ":"
                                                                                        + enumtype
                                                                                              .getUnlocalizedName()
                                                                                        + "_titanium", "inventory");
        Minecraft.getMinecraft().getRenderItem().getItemModelMesher()
                 .register(itemBlockVariants, enumtype.getMetadata(), itemModelResourceLocation);
    }
}

项目：Minestrappolation-4 文件：BlockBiomeCoal.java

public static void inventoryRender()
{
    Item itemBlockBrickVariants = GameRegistry.findItem(MReference.MODID, "biome_coal");

    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:deepstone_coal");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:coldstone_coal");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:icestone_coal");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:glacierrock_coal");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:deep_coldstone_coal");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:red_rock_coal");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:deep_redrock_coal");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:oceanstone_coal");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:pressurized_oceanstone_coal");

    Item itemBlockVariants = GameRegistry.findItem(MReference.MODID, "biome_coal");
    MStoneType[] aenumtype = MStoneType.values();
    int i = aenumtype.length;

    for (int j = 0; j < i; ++j)
    {
        MStoneType enumtype = aenumtype[j];
        ModelResourceLocation itemModelResourceLocation = new ModelResourceLocation(MReference.MODID + ":"
                                                                                        + enumtype
                                                                                              .getUnlocalizedName()
                                                                                        + "_coal", "inventory");
        Minecraft.getMinecraft().getRenderItem().getItemModelMesher()
                 .register(itemBlockVariants, enumtype.getMetadata(), itemModelResourceLocation);
    }
}

项目：Minestrappolation-4 文件：BlockBiomeMeurodite.java

public static void inventoryRender()
{
    Item itemBlockBrickVariants = GameRegistry.findItem(MReference.MODID, "biome_meurodite");

    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:deepstone_meurodite");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:coldstone_meurodite");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:icestone_meurodite");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:glacierrock_meurodite");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:deep_coldstone_meurodite");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:red_rock_meurodite");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:deep_redrock_meurodite");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:oceanstone_meurodite");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:pressurized_oceanstone_meurodite");

    Item itemBlockVariants = GameRegistry.findItem(MReference.MODID, "biome_meurodite");
    MStoneType[] aenumtype = MStoneType.values();
    int i = aenumtype.length;

    for (int j = 0; j < i; ++j)
    {
        MStoneType enumtype = aenumtype[j];
        ModelResourceLocation itemModelResourceLocation = new ModelResourceLocation(MReference.MODID + ":"
                                                                                        + enumtype
                                                                                              .getUnlocalizedName()
                                                                                        + "_meurodite",
                                                                                    "inventory");
        Minecraft.getMinecraft().getRenderItem().getItemModelMesher()
                 .register(itemBlockVariants, enumtype.getMetadata(), itemModelResourceLocation);
    }
}

项目：Minestrappolation-4 文件：BlockBiomeTorite.java

public static void inventoryRender()
{
    Item itemBlockBrickVariants = GameRegistry.findItem(MReference.MODID, "biome_torite");

    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:deepstone_torite");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:coldstone_torite");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:icestone_torite");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:glacierrock_torite");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:deep_coldstone_torite");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:red_rock_torite");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:deep_redrock_torite");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:oceanstone_torite");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:pressurized_oceanstone_torite");

    Item itemBlockVariants = GameRegistry.findItem(MReference.MODID, "biome_torite");
    MStoneType[] aenumtype = MStoneType.values();
    int i = aenumtype.length;

    for (int j = 0; j < i; ++j)
    {
        MStoneType enumtype = aenumtype[j];
        ModelResourceLocation itemModelResourceLocation = new ModelResourceLocation(MReference.MODID + ":"
                                                                                        + enumtype
                                                                                              .getUnlocalizedName()
                                                                                        + "_torite", "inventory");
        Minecraft.getMinecraft().getRenderItem().getItemModelMesher()
                 .register(itemBlockVariants, enumtype.getMetadata(), itemModelResourceLocation);
    }
}

项目：Minestrappolation-4 文件：BlockBiomeRadiant.java

public static void inventoryRender()
{
    Item itemBlockBrickVariants = GameRegistry.findItem(MReference.MODID, "biome_radiant");

    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:deepstone_radiant");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:coldstone_radiant");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:icestone_radiant");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:glacierrock_radiant");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:deep_coldstone_radiant");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:red_rock_radiant");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:deep_redrock_radiant");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:oceanstone_radiant");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:pressurized_oceanstone_radiant");

    Item itemBlockVariants = GameRegistry.findItem(MReference.MODID, "biome_radiant");
    MStoneType[] aenumtype = MStoneType.values();
    int i = aenumtype.length;

    for (int j = 0; j < i; ++j)
    {
        MStoneType enumtype = aenumtype[j];
        ModelResourceLocation itemModelResourceLocation = new ModelResourceLocation(MReference.MODID + ":"
                                                                                        + enumtype
                                                                                              .getUnlocalizedName()
                                                                                        + "_radiant", "inventory");
        Minecraft.getMinecraft().getRenderItem().getItemModelMesher()
                 .register(itemBlockVariants, enumtype.getMetadata(), itemModelResourceLocation);
    }
}

项目：Minestrappolation-4 文件：BlockBiomeEmerald.java

public static void inventoryRender()
{
    Item itemBlockBrickVariants = GameRegistry.findItem(MReference.MODID, "biome_emerald");

    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:deepstone_emerald");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:coldstone_emerald");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:icestone_emerald");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:glacierrock_emerald");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:deep_coldstone_emerald");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:red_rock_emerald");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:deep_redrock_emerald");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:oceanstone_emerald");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:pressurized_oceanstone_emerald");

    Item itemBlockVariants = GameRegistry.findItem(MReference.MODID, "biome_emerald");
    MStoneType[] aenumtype = MStoneType.values();
    int i = aenumtype.length;

    for (int j = 0; j < i; ++j)
    {
        MStoneType enumtype = aenumtype[j];
        ModelResourceLocation itemModelResourceLocation = new ModelResourceLocation(MReference.MODID + ":"
                                                                                        + enumtype
                                                                                              .getUnlocalizedName()
                                                                                        + "_emerald", "inventory");
        Minecraft.getMinecraft().getRenderItem().getItemModelMesher()
                 .register(itemBlockVariants, enumtype.getMetadata(), itemModelResourceLocation);
    }
}

项目：Minestrappolation-4 文件：BlockBiomeRedstone.java

public static void inventoryRender()
{
    Item itemBlockBrickVariants = GameRegistry.findItem(MReference.MODID, "biome_redstone");

    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:deepstone_redstone");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:coldstone_redstone");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:icestone_redstone");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:glacierrock_redstone");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:deep_coldstone_redstone");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:red_rock_redstone");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:deep_redrock_redstone");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:oceanstone_redstone");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:pressurized_oceanstone_redstone");

    Item itemBlockVariants = GameRegistry.findItem(MReference.MODID, "biome_redstone");
    MStoneType[] aenumtype = MStoneType.values();
    int i = aenumtype.length;

    for (int j = 0; j < i; ++j)
    {
        MStoneType enumtype = aenumtype[j];
        ModelResourceLocation itemModelResourceLocation = new ModelResourceLocation(MReference.MODID + ":"
                                                                                        + enumtype
                                                                                              .getUnlocalizedName()
                                                                                        + "_redstone", "inventory");
        Minecraft.getMinecraft().getRenderItem().getItemModelMesher()
                 .register(itemBlockVariants, enumtype.getMetadata(), itemModelResourceLocation);
    }
}

项目：Minestrappolation-4 文件：BlockBiomeCobble.java

public static void inventoryRender()
{
    Item itemBlockBrickVariants = GameRegistry.findItem(MReference.MODID, "biome_cobble");

    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:deepstone_cobble");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:coldstone_cobble");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:icestone_cobble");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:glacierrock_cobble");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:deep_coldstone_cobble");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:red_rock_cobble");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:deep_redrock_cobble");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:oceanstone_cobble");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:pressurized_oceanstone_cobble");

    Item itemBlockVariants = GameRegistry.findItem(MReference.MODID, "biome_cobble");
    MStoneType[] aenumtype = MStoneType.values();
    int i = aenumtype.length;

    for (int j = 0; j < i; ++j)
    {
        MStoneType enumtype = aenumtype[j];
        ModelResourceLocation itemModelResourceLocation = new ModelResourceLocation(MReference.MODID + ":"
                                                                                        + enumtype
                                                                                              .getUnlocalizedName()
                                                                                        + "_cobble", "inventory");
        Minecraft.getMinecraft().getRenderItem().getItemModelMesher()
                 .register(itemBlockVariants, enumtype.getMetadata(), itemModelResourceLocation);
    }
}

项目：Minestrappolation-4 文件：BlockBiomeLapis.java

public static void inventoryRender()
{
    Item itemBlockBrickVariants = GameRegistry.findItem(MReference.MODID, "biome_lapis");

    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:deepstone_lapis");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:coldstone_lapis");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:icestone_lapis");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:glacierrock_lapis");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:deep_coldstone_lapis");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:red_rock_lapis");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:deep_redrock_lapis");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:oceanstone_lapis");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:pressurized_oceanstone_lapis");

    Item itemBlockVariants = GameRegistry.findItem(MReference.MODID, "biome_lapis");
    MStoneType[] aenumtype = MStoneType.values();
    int i = aenumtype.length;

    for (int j = 0; j < i; ++j)
    {
        MStoneType enumtype = aenumtype[j];
        ModelResourceLocation itemModelResourceLocation = new ModelResourceLocation(MReference.MODID + ":"
                                                                                        + enumtype
                                                                                              .getUnlocalizedName()
                                                                                        + "_lapis", "inventory");
        Minecraft.getMinecraft().getRenderItem().getItemModelMesher()
                 .register(itemBlockVariants, enumtype.getMetadata(), itemModelResourceLocation);
    }
}

项目：Minestrappolation-4 文件：BlockBiomeIron.java

public static void inventoryRender()
{
    Item itemBlockBrickVariants = GameRegistry.findItem(MReference.MODID, "biome_iron");

    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:deepstone_iron");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:coldstone_iron");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:icestone_iron");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:glacierrock_iron");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:deep_coldstone_iron");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:red_rock_iron");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:deep_redrock_iron");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:oceanstone_iron");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:pressurized_oceanstone_iron");

    Item itemBlockVariants = GameRegistry.findItem(MReference.MODID, "biome_iron");
    MStoneType[] aenumtype = MStoneType.values();
    int i = aenumtype.length;

    for (int j = 0; j < i; ++j)
    {
        MStoneType enumtype = aenumtype[j];
        ModelResourceLocation itemModelResourceLocation = new ModelResourceLocation(MReference.MODID + ":"
                                                                                        + enumtype
                                                                                              .getUnlocalizedName()
                                                                                        + "_iron", "inventory");
        Minecraft.getMinecraft().getRenderItem().getItemModelMesher()
                 .register(itemBlockVariants, enumtype.getMetadata(), itemModelResourceLocation);
    }
}

项目：Minestrappolation-4 文件：BlockBiomeCopper.java

public static void inventoryRender()
{
    Item itemBlockBrickVariants = GameRegistry.findItem(MReference.MODID, "biome_copper");

    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:deepstone_copper");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:coldstone_copper");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:icestone_copper");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:glacierrock_copper");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:deep_coldstone_copper");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:red_rock_copper");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:deep_redrock_copper");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:oceanstone_copper");
    ModelBakery.addVariantName(itemBlockBrickVariants, "ministrapp:pressurized_oceanstone_copper");

    Item itemBlockVariants = GameRegistry.findItem(MReference.MODID, "biome_copper");
    MStoneType[] aenumtype = MStoneType.values();
    int i = aenumtype.length;

    for (int j = 0; j < i; ++j)
    {
        MStoneType enumtype = aenumtype[j];
        ModelResourceLocation itemModelResourceLocation = new ModelResourceLocation(MReference.MODID + ":"
                                                                                        + enumtype
                                                                                              .getUnlocalizedName()
                                                                                        + "_copper", "inventory");
        Minecraft.getMinecraft().getRenderItem().getItemModelMesher()
                 .register(itemBlockVariants, enumtype.getMetadata(), itemModelResourceLocation);
    }
}