How to use

IToolPart

in

slimeknights.tconstruct.library.tools

 @SideOnly(Side.CLIENT)
 default ItemStack getOutlineRenderStack() {
  return getItemstackWithMaterial(CustomTextureCreator.guiMaterial);
 }
}

/**
 * Used for the sharpening kit. Allows to register a toolpart that is not part of a tool.
 */
public static void registerToolPart(IToolPart part) {
 toolParts.add(part);
 if(part instanceof Item) {
  if(part.canBeCrafted()) {
   addPatternForItem((Item) part);
  }
  if(part.canBeCasted()) {
   addCastForItem((Item) part);
  }
 }
}

/**
 * Workaround for dual-materials like crossbow-bolts.
 * E.g. Obsidian is not an "acceptable" material because those are only shaft materials
 * but we still need to generate the texture for it.
 */
default boolean canUseMaterialForRendering(Material mat) {
 return canUseMaterial(mat);
}

if(!toolPart.canBeCasted()) {
 continue;
if(!toolPart.canUseMaterial(material)) {
 continue;
 ItemStack stack = toolPart.getItemstackWithMaterial(material);
 ItemStack cast = new ItemStack(TinkerSmeltery.cast);
 Cast.setTagForPart(cast, stack.getItem());
  TinkerRegistry.registerMelting(stack, fluid, toolPart.getCost());
  TinkerRegistry.registerTableCasting(stack, cast, fluid, toolPart.getCost());
   FluidStack fs = new FluidStack(fluid, toolPart.getCost());
   TinkerRegistry.registerTableCasting(new CastingRecipe(stack, rm, fs, true, false));

if(toolPart.canBeCasted()) {
 if(toolPart instanceof MaterialItem) {
  ItemStack stack = toolPart.getItemstackWithMaterial(TinkerMaterials.stone);
  TinkerRegistry.registerMelting(stack, TinkerFluids.searedStone, (toolPart.getCost() * Material.VALUE_SearedMaterial) / Material.VALUE_Ingot);

.filter(part -> part.hasUseForStat(stats.getIdentifier()))
.map(part -> part.getItemstackWithMaterial(material))
.collect(Collectors.toList()));

  continue;
 Optional<RecipeMatch.Match> newMatch = material.matches(materialItems, part.getCost());
 if(!newMatch.isPresent()) {
  continue;
 return null;
if(output.getItem() instanceof IToolPart && !((IToolPart) output.getItem()).canUseMaterial(foundMaterial)) {
 return null;
int leftover = (match.get().amount - part.getCost()) / Material.VALUE_Shard;
if(leftover > 0) {
 secondary = TinkerRegistry.getShard(foundMaterial);

  @Nonnull
  @Override
  public Map<Object, Object> getMeta(@Nonnull ItemStack stack) {
    Item item = stack.getItem();
    if (!(item instanceof IToolPart)) return Collections.emptyMap();

    IToolPart toolPart = (IToolPart) item;

    Map<Object, Object> out = Maps.newHashMap();
    out.put("cost", toolPart.getCost());
    return out;
  }
}

public boolean isValid(ItemStack stack) {
 if(stack.getItem() instanceof IToolPart) {
  IToolPart toolPart = (IToolPart) stack.getItem();
  return isValid(toolPart, toolPart.getMaterial(stack));
 }
 return false;
}

 @SideOnly(Side.CLIENT)
 public void updateIcon() {
  icon = null;
  if(restriction != null) {
   Iterator<IToolPart> iterator = restriction.getPossibleParts().iterator();
   while(iterator.hasNext() && icon == null) {
    icon = iterator.next().getOutlineRenderStack();
   }
  }
 }
}

usable = false;
for(IToolPart toolPart : parts) {
 usable |= toolPart.canUseMaterialForRendering(material);

private void addStatsDisplay(int x, int y, int w, ArrayList<BookElement> list, LinkedHashSet<ITrait> allTraits, String stattype) {
 IMaterialStats stats = material.getStats(stattype);
 if(stats == null) {
  return;
 }
 List<ITrait> traits = material.getAllTraitsForStats(stats.getIdentifier());
 allTraits.addAll(traits);
 // create a list of all valid toolparts with the stats
 List<ItemStack> parts = Lists.newLinkedList();
 for(IToolPart part : TinkerRegistry.getToolParts()) {
  if(part.hasUseForStat(stats.getIdentifier())) {
   parts.add(part.getItemstackWithMaterial(material));
  }
 }
 // said parts next to the name
 if(parts.size() > 0) {
  ElementItem display = new ElementTinkerItem(x, y + 1, 0.5f, parts);
  list.add(display);
 }
 // and the name itself
 ElementText name = new ElementText(x + 10, y, w - 10, 10, stats.getLocalizedName());
 name.text[0].underlined = true;
 list.add(name);
 y += 12;
 List<TextData> lineData = Lists.newArrayList();
 // add lines of tool information
 lineData.addAll(getStatLines(stats));
 lineData.addAll(getTraitLines(traits, material));
 list.add(new ElementText(x, y, w, GuiBook.PAGE_HEIGHT, lineData));
}

if(part instanceof IToolPart && matchAmount < ((IToolPart) part).getCost()) {
 amount = TextFormatting.DARK_RED + amount + TextFormatting.RESET;

for(int j = 0; j < pms.size(); j++) {
 PartMaterialType pmt = pms.get(j);
 String partMat = ((IToolPart) part.getItem()).getMaterial(part).getIdentifier();
 String currentMat = materialList.getStringTagAt(j);
String mat = ((IToolPart) toolParts.get(i).getItem()).getMaterial(toolParts.get(i)).getIdentifier();
materialList.set(j, new NBTTagString(mat));
if(removeItems) {

 private List<ItemStack> getItems(IToolPart part) {
  List<Material> possibleMaterials = TinkerRegistry.getAllMaterials().stream()
                           .filter(part::canUseMaterial)
                           .collect(Collectors.toList());
  Material material = possibleMaterials.get(new Random().nextInt(possibleMaterials.size()));

  return ImmutableList.<ItemStack>builder()
    .add(part.getItemstackWithMaterial(material))
    .addAll(ModExtraTrait.EMBOSSMENT_ITEMS)
    .build();
 }
}

Item part = getPartFromTag(stack);
if(part != null && part instanceof IToolPart) {
 float cost = ((IToolPart) part).getCost() / (float) Material.VALUE_Ingot;
 tooltip.add(Util.translateFormatted("tooltip.pattern.cost", Util.df.format(cost)));

protected boolean isValidSubitem(Item toolpart) {
 if(toolpart instanceof IToolPart) {
  for(Material material : TinkerRegistry.getAllMaterials()) {
   if(isValidSubitemMaterial(material) && ((IToolPart) toolpart).canUseMaterial(material)) {
    return true;
   }
  }
  return false;
 }
 return true;
}

ItemStack partStack = part.getItemstackWithMaterial(material);
if(partStack != null) {

ItemStack[] stacks = items.stream().map(part -> part.getItemstackWithMaterial(material)).toArray(ItemStack[]::new);

ItemStack partStack = part.getItemstackWithMaterial(material);
if (partStack != null) {
  parts.put(++partIdx, context.makePartialChild(pmt).makePartialChild(partStack).getMeta());