@Override public void setCustomModelResourceLocation( Item item, int metadata, ModelResourceLocation model ) { ModelLoader.setCustomModelResourceLocation( item, metadata, model ); }
@Override public void setCustomStateMapper( Block block, IStateMapper mapper ) { ModelLoader.setCustomStateMapper( block, mapper ); } }
ModelLoader.setCustomModelResourceLocation(tableItem, BlockToolTable.TableTypes.CraftingStation.meta, ToolClientEvents.locCraftingStation); ModelLoader.setCustomModelResourceLocation(tableItem, BlockToolTable.TableTypes.StencilTable.meta, ToolClientEvents.locStencilTable); ModelLoader.setCustomModelResourceLocation(tableItem, BlockToolTable.TableTypes.PartBuilder.meta, ToolClientEvents.locPartBuilder); ModelLoader.setCustomModelResourceLocation(tableItem, BlockToolTable.TableTypes.ToolStation.meta, ToolClientEvents.locToolStation); ModelLoader.setCustomModelResourceLocation(tableItem, BlockToolTable.TableTypes.PatternChest.meta, ToolClientEvents.locPatternChest); ModelLoader.setCustomModelResourceLocation(tableItem, BlockToolTable.TableTypes.PartChest.meta, ToolClientEvents.locPartChest); ModelLoader.setCustomModelResourceLocation(tableItem, 0, ToolClientEvents.locToolForge); ModelLoader.setCustomMeshDefinition(TinkerTools.pattern, new PatternMeshDefinition(patternLoc)); final ModelResourceLocation boltCoreGuiModelLocation = Util.getModelResource("parts/bolt_core_gui", ModelRegisterUtil.VARIANT_INVENTORY); ModelLoader.setCustomMeshDefinition(TinkerTools.boltCore, stack -> { if(stack == BoltCore.GUI_RENDER_ITEMSTACK) { return boltCoreGuiModelLocation; }); ModelLoader.registerItemVariants(TinkerTools.boltCore, boltCoreGuiModelLocation); ModelLoader.registerItemVariants(TinkerTools.boltCore, boltCoreModelLocation);
/** Registers the item-meta combo in the itemstack with the given location for the inventory-variant */ public static void registerItemModel(ItemStack itemStack, ResourceLocation name) { if(!itemStack.isEmpty() && name != null) { // tell the loader to load the model ModelLoader.registerItemVariants(itemStack.getItem(), name); // tell the game which model to use for this item-meta combination ModelLoader.setCustomModelResourceLocation(itemStack.getItem(), itemStack.getMetadata(), new ModelResourceLocation(name, VARIANT_INVENTORY)); } }
private static ResourceLocation registerIt(Item item, final ResourceLocation location) { // plop it in. // This here is needed for the model to be found ingame when the game looks for a model to render an Itemstack // we use an ItemMeshDefinition because it allows us to do it no matter what metadata we use ModelLoader.setCustomMeshDefinition(item, new ItemMeshDefinition() { @Nonnull @Override public ModelResourceLocation getModelLocation(@Nonnull ItemStack stack) { return new ModelResourceLocation(location, VARIANT_INVENTORY); } }); // We have to readd the default variant if we have custom variants, since it wont be added otherwise and therefore not loaded ModelLoader.registerItemVariants(item, location); return location; }
@Override public void registerFluidModels(Fluid fluid) { if(fluid == null) { return; } Block block = fluid.getBlock(); if(block != null) { Item item = Item.getItemFromBlock(block); FluidStateMapper mapper = new FluidStateMapper(fluid); // item-model if(item != Items.AIR) { ModelLoader.registerItemVariants(item); ModelLoader.setCustomMeshDefinition(item, mapper); } // block-model ModelLoader.setCustomStateMapper(block, mapper); } }
@SideOnly(Side.CLIENT) private void registerRender(Item item, ModelResourceLocation location) { ModelLoader.setCustomModelResourceLocation(item, 0, location); if (item instanceof CustomModelMasking && ((CustomModelMasking) item).getItemMeshDefinition() != null) ModelLoader.setCustomMeshDefinition(item, ((CustomModelMasking) item).getItemMeshDefinition()); else ModelLoader.setCustomMeshDefinition(item, stack -> location); }
public void addBuiltInBlock(Block block, String particleTexture) { this.builtInBlocks.add(new Tuple<>(block, particleTexture)); ModelLoader.setCustomStateMapper(block, SIMPLE_STATE_MAPPER); Item itemFromBlock = Item.getItemFromBlock(block); if(itemFromBlock != Items.AIR) { ModelLoader.setCustomMeshDefinition(itemFromBlock, SIMPLE_MESH_DEFINITION); } }
@Override public void registerModels() { ModelLoader.setCustomStateMapper(TinkerSmeltery.searedGlass, (new StateMap.Builder()).ignore(BlockSearedGlass.TYPE).build()); BlockSmelteryIO.TYPE.getName(type) ); ModelLoader.setCustomModelResourceLocation(drain, type.meta, new ModelResourceLocation(drain.getRegistryName(), variant)); ModelLoader.setCustomModelResourceLocation(tank, type.meta, new ModelResourceLocation(tank.getRegistryName(), type.getName())); ModelLoader.setCustomMeshDefinition(TinkerSmeltery.cast, new PatternMeshDefinition(castLoc)); CustomTextureCreator.castModelLocation = new ResourceLocation(clayCastLoc.getResourceDomain(), "item/" + clayCastLoc.getResourcePath()); ModelLoader.setCustomMeshDefinition(TinkerSmeltery.clayCast, new PatternMeshDefinition(clayCastLoc));
ModelLoader.setCustomStateMapper(TinkerGadgets.slimeChannel, new PropertyStateMapper("slime_channel", BlockSlimeChannel.SIDE, BlockSlimeChannel.TYPE)); String variant = RenderFancyItemFrame.getVariant(type, withMap); ModelResourceLocation loc = Util.getModelResource("fancy_frame", variant); ModelLoader.registerItemVariants(TinkerGadgets.fancyFrame, loc); if(!withMap) { ModelLoader.setCustomModelResourceLocation(TinkerGadgets.fancyFrame, type.ordinal(), loc);
@Override public void setCustomMeshDefinition( Item item, ItemMeshDefinition meshDefinition ) { ModelLoader.setCustomMeshDefinition( item, meshDefinition ); }
@Override public void registerModels() { ModelLoader.setCustomStateMapper(TinkerWorld.slimeGrass, (new StateMap.Builder()).ignore(BlockSlimeGrass.FOLIAGE).build()); ModelLoader.setCustomStateMapper(TinkerWorld.slimeLeaves, (new StateMap.Builder()) .ignore(BlockSlimeGrass.FOLIAGE, BlockLeaves.CHECK_DECAY, BlockLeaves.DECAYABLE).build()); ModelLoader.setCustomStateMapper(TinkerWorld.slimeGrassTall, (new StateMap.Builder()).ignore(BlockSlimeGrass.FOLIAGE).build()); ModelLoader.setCustomStateMapper(TinkerWorld.slimeSapling, (new StateMap.Builder()).ignore(BlockSlimeSapling.STAGE, BlockSapling.TYPE).build()); ModelLoader.setCustomStateMapper(TinkerWorld.slimeVineBlue1, vineMap); ModelLoader.setCustomStateMapper(TinkerWorld.slimeVinePurple1, vineMap); vineMap = new CustomStateMap("slime_vine_mid"); ModelLoader.setCustomStateMapper(TinkerWorld.slimeVineBlue2, vineMap); ModelLoader.setCustomStateMapper(TinkerWorld.slimeVinePurple2, vineMap); vineMap = new CustomStateMap("slime_vine_end"); ModelLoader.setCustomStateMapper(TinkerWorld.slimeVineBlue3, vineMap); ModelLoader.setCustomStateMapper(TinkerWorld.slimeVinePurple3, vineMap); .withProperty(BlockSlimeGrass.TYPE, dirt) .withProperty(BlockSlimeGrass.FOLIAGE, type)); ModelLoader.setCustomModelResourceLocation(grass, meta, new ModelResourceLocation(grass.getRegistryName(), variant)); ModelLoader.setCustomModelResourceLocation(leaves, type.getMeta(), new ModelResourceLocation(leaves.getRegistryName(), "normal"));
@Override public void registerItemVariants( Item item, ResourceLocation... names ) { ModelLoader.registerItemVariants( item, names ); }
@Override public IBakedModel bake(IModelState state, VertexFormat format, Function<ResourceLocation, TextureAtlasSprite> bakedTextureGetter) { ImmutableMap<ItemCameraTransforms.TransformType, TRSRTransformation> transforms = PerspectiveMapWrapper.getTransforms(state); IModelState transformState = new SimpleModelState(transforms); IBakedModel baseModelBaked = ModelLoaderRegistry.getModelOrMissing(baseModel) .bake(transformState, DefaultVertexFormats.ITEM, ModelLoader.defaultTextureGetter()); ImmutableMap.Builder<String, IBakedModel> bakedBlockBuilder = ImmutableMap.builder(); for(Map.Entry<String, ModelResourceLocation> e : blockModels.entrySet()) { IModel model = ModelLoaderRegistry.getModelOrMissing(e.getValue()); if(model != ModelLoaderRegistry.getMissingModel()) bakedBlockBuilder.put(e.getKey(), model.bake(transformState, DefaultVertexFormats.ITEM, ModelLoader.defaultTextureGetter())); } ImmutableMap.Builder<String, IBakedModel> bakedItemBuilder = ImmutableMap.builder(); for(Map.Entry<String, ModelResourceLocation> e : itemModels.entrySet()) { IModel model = ModelLoaderRegistry.getModelOrMissing(e.getValue()); if(model != ModelLoaderRegistry.getMissingModel()) bakedItemBuilder.put(e.getKey(), model.bake(transformState, DefaultVertexFormats.ITEM, ModelLoader.defaultTextureGetter())); } return new SpecialFlowerBakedModel(baseModelBaked, bakedBlockBuilder.build(), bakedItemBuilder.build(), transforms); }
@Override @SideOnly (Side.CLIENT) public void registerModels() { StateMapper mapper = new StateMapper(modName, "util", name); ModelLoader.setCustomMeshDefinition(this, mapper); ModelLoader.setCustomModelResourceLocation(this, 0, new ModelResourceLocation(modName + ":" + "util", "type=" + name)); }
@SideOnly(Side.CLIENT) public static void preInitClient() { ModelLoader.setCustomMeshDefinition(SEEDS, new MeshIdentical(SEEDS)); ModelLoader.setCustomStateMapper(CROPS, new CropStateMapper()); }
/** Registers the item-meta combo in the itemstack with the given location for the inventory-variant */ public static void registerItemModel(ItemStack itemStack, ResourceLocation name) { if (!itemStack.isEmpty() && name != null) { // tell the loader to load the model ModelLoader.registerItemVariants(itemStack.getItem(), name); // tell the game which model to use for this item-meta combination ModelLoader.setCustomModelResourceLocation(itemStack.getItem(), itemStack.getMetadata(), new ModelResourceLocation(name, VARIANT_INVENTORY)); } }
/** * (Excerpted from Tinkers' Construct with permission, thanks guys!) */ private static void registerCustomFluidBlockRenderer(Fluid fluid){ Block block = fluid.getBlock(); Item item = Item.getItemFromBlock(block); FluidStateMapper mapper = new FluidStateMapper(fluid); ModelLoader.registerItemVariants(item); ModelLoader.setCustomMeshDefinition(item, mapper); ModelLoader.setCustomStateMapper(block, mapper); }
@SideOnly(Side.CLIENT) @Override public void registerModels() { // Load and bake the 2D models ModelBakery.registerItemVariants(this, new ModelResourceLocation("botania:lexicon_default", "inventory"), new ModelResourceLocation("botania:lexicon_elven", "inventory")); ModelResourceLocation default3dPath = new ModelResourceLocation("botania:lexicon_3d_default", "inventory"); ModelResourceLocation elven3dPath = new ModelResourceLocation("botania:lexicon_3d_elven", "inventory"); // smart model will dispatch between 2d/3d appropriately, see LexiconModel ModelLoader.setCustomMeshDefinition(this, stack -> isElvenItem(stack) ? elven3dPath : default3dPath); }
/** * Registers all variants of an {@link IItemWithTier} as well as the custom mesh * definition Only works with items that only have variants based on tier */ private static void registerSimpleItemWithTier(IItemWithTier itemWithTier) { Item item = (Item) itemWithTier; ResourceLocation loc = new ResourceLocation(REFERENCE.MODID, "item/" + item.getRegistryName().getResourcePath()); ModelLoader.setCustomMeshDefinition(item, new IItemWithTier.SimpleMeshDefinition(loc)); for (IStringSerializable s : IItemWithTier.TIER.values()) { ModelLoader.registerItemVariants(item, new ModelResourceLocation(loc, "tier=" + s.getName())); } }