I want to create items which will render differently depending on information stored in an ItemStack capability. My goal is a bit similar to how vanilla items are rendered with a durability bar: the underlying item remains the same but there is another layer rendered on top which is one of a few textures. The possible overlay textures are the same for all the different items that have this property (just like the vanilla durability bar is the same for all items with durability), but the underlying item texture is different for each.

 

I think I'll need to use item property override like the vanilla bow, but I just don't really understand how and can't find any tutorials or explanations. I can't figure out how the property override gets converted into json-usable information. I also really don't want to have to make multiple model files for every single item when they will all be using the same set of properties and overlays, so I'd like to figure out how to make some kind of abstract json that can be 'subclassed' without having to redefine things every time. But, I also don't know how to do that. And when I try searching for minecraft json help I mostly just find stuff about blockstates. A summary of my questions:

 

1. How exactly does item property override work? Is there a tutorial I can refer to? The

apply

method returns a float, but where does this go and how is it converted into different item textures?

2. How does inheritance work with json models? How would I go about making a parent model which uses the same overlays for the same item property override, but with a base texture that can be specified for each item type?

A good tutorial about the game:

 

http://greyminecraftcoder.blogspot.com.au/p/list-of-topics.html

I've made some progress. I've got a working item property override for a single item now. But the downsides is, I had to make four models for a single item that has this property. And I'm planning to have a lot of items with the same overlay property. Does anyone have any idea if I can make a generic/abstract version of the model (which applies the overlay textures according to the item property) which I can then extend by just adding the item's base textures? It seems so excessive to have to make endless really simple models which all have the same overrides. D:

 

Edit: for reference, I'll show how I'm using property override. My item class:

 

 

package com.jj.jjmod.items;

import javax.annotation.Nullable;
import com.jj.jjmod.capabilities.CapDecay;
import com.jj.jjmod.capabilities.DefaultCapDecay;
import com.jj.jjmod.capabilities.ProviderCapDecay;
import net.minecraft.entity.Entity;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.item.IItemPropertyGetter;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.util.ResourceLocation;
import net.minecraft.world.World;
import net.minecraftforge.common.capabilities.ICapabilityProvider;
import net.minecraftforge.fml.relauncher.Side;
import net.minecraftforge.fml.relauncher.SideOnly;

public class ItemEdibleDecayable extends ItemEdible {

    public ItemEdibleDecayable(String name, int hunger, float saturation,
            int stackSize) {
        
        super(name, hunger, saturation, stackSize);
        this.addPropertyOverride(new ResourceLocation("decay"), new IItemPropertyGetter() {

            @Override
            public float apply(ItemStack stack, World worldIn,
                    EntityLivingBase entityIn) {

                if (entityIn == null) {
                    
                    return 0F;
                }
                
                float decay = stack.getCapability(CapDecay.CAP_DECAY, null).getFraction();
                
                if (decay < 0.5) {
                    
                    return 0.5F;
                    
                } else if (decay < 0.75) {
                    
                    return 0.75F;
                    
                } else {
                    
                    return 1.0F;
                }
            }
        });
    }
    
    @Override
    public ICapabilityProvider initCapabilities(ItemStack stack, NBTTagCompound nbt) {
        
        return new ProviderCapDecay(new DefaultCapDecay(10));
    }
    
    @Override
    public void onUpdate(ItemStack stack, World world, Entity entity, int slot, boolean isSelected) {
        
        stack.getCapability(CapDecay.CAP_DECAY, null).update();
    }
}

 

 

My item model json:

 

{
    "parent": "item/generated",
    "textures": {
        "layer0": "jjmod:items/banana"
    },
    "overrides": [
        {
            "predicate": {
                "decay": 0.5
            },
            "model": "jjmod:item/item_bananaFresh"
        },
        {
            "predicate": {
                "decay": 0.75
            },
            "model": "jjmod:item/item_bananaStale"
        },
        {
            "predicate": {
                "decay": 1.0
            },
            "model": "jjmod:item/item_bananaOld"
        }
    ]
}

 

 

And the extra model files for the variants:

 

{
    "parent": "item/generated",
    "textures": {
        "layer0": "jjmod:items/banana",
        "layer1": "jjmod:items/foodFresh"
    }
}

 

{
    "parent": "item/generated",
    "textures": {
        "layer0": "jjmod:items/banana",
        "layer1": "jjmod:items/foodStale"
    }
}

 

{
    "parent": "item/generated",
    "textures": {
        "layer0": "jjmod:items/banana",
        "layer1": "jjmod:items/foodOld"
    }
}

 

 

And as I said, the property override and models are working as they should - I'm just hoping there's a more efficient way than creating many files for every item.

Hey did you ever figure out how to create a generic version of the model then overlay textures according to properties onto it? This is exactly what I'm trying to figure out myself.

Please don’t necro old threads, if you have an issue please make your own thread.