VORAUSSETZUNGEN
Stelle sicher, dass du die Einrichtung des Datengenerators abgeschlossen und dein erstes Item erstellt hast.
Für jedes Itemmodell, das wir generieren möchten, müssen wir zwei separate JSON-Dateien erstellen:
- Ein Itemmodell, das die Texturen, die Drehung und das allgemeine Aussehen des Items definiert. Es wird im Verzeichnis
generated/assets/example-mod/models/itemabgelegt. - Ein Client Item, das anhand verschiedener Kriterien wie Komponenten, Interaktionen und mehr definiert, welches Modell verwendet werden soll. Es wird im Verzeichnis
generated/assets/example-mod/itemsabgelegt.
Einrichtung
Zuerst müssen wir unseren Modell Provider erstellen.
TIP
Du kannst den FabricModelProvider wiederverwenden, der in Generation von Blockmodellen erstellt wurde.
Erstellen eine Klasse, die von FabricModelProvider erbt, und implementiere die beiden abstrakten Methoden: generateBlockStateModels und generateItemModels. Dann erstelle einen Konstruktor, der mit super übereinstimmt.
java
public class ExampleModModelProvider extends FabricModelProvider {
public ExampleModModelProvider(FabricDataOutput output) {
super(output);
}
@Override
public void generateBlockStateModels(BlockModelGenerators blockStateModelGenerator) {
}
@Override
public void generateItemModels(ItemModelGenerators itemModelGenerator) {
}
@Override
public String getName() {
return "ExampleModModelProvider";
}
}1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
Registriere diese Klasse in deinem DataGeneratorEntrypoint innerhalb der Methode onInitializeDataGenerator.
java
pack.addProvider(ExampleModModelProvider::new);1
Eingebaute Itemmodelle
Für Itemmodelle verwenden wir die Methode generateItemModels. Sein Parameter ItemModelGenerators itemModelGenerator ist für die Generierung der Itemmodelle zuständig und enthält auch Methoden, um dies zu tun.
Hier findest du eine Übersicht über die am häufigsten verwendeten Methoden des Itemmodell Generators.
Einfach
Einfache Itemmodelle sind der Standard und werden von den meisten Minecraft Items verwendet. Ihr übergeordnetes Modell ist GENERATED. Sie verwenden ihre 2D-Textur im Inventar und werden im Spiel in 3D gerendert. Ein Beispiel wären Boote, Kerzen oder Farbstoffe.
java
itemModelGenerator.generateFlatItem(ModItems.RUBY, ModelTemplates.FLAT_ITEM);1
Handgehalten
Handgehaltene Itemmodelle werden in der Regel für Werkzeuge und Waffen (Äxte, Schwerter, Dreizack) verwendet. Sie sind etwas anders rotiert und positioniert als die einfachen Modelle, damit sie in der Hand natürlicher aussehen.
java
itemModelGenerator.generateFlatItem(ModItems.GUIDITE_AXE, ModelTemplates.FLAT_HANDHELD_ITEM);1
Färbbar
Die Methode für färbbare Items generiert ein einfaches Itemmodell und ein Client Item, der die Farbe der Färbung angibt. Diese Methode erfordert einen Standard-Dezimalwert für die Farbe, der verwendet wird, wenn das Item nicht gefärbt ist. Der Standardwert für Leder ist 0xFFA06540.
java
itemModelGenerator.generateDyedItem(ModItems.LEATHER_GLOVES, 0xFFA06540);1
WICHTIG
Du musst dein Item zu dem Tag temTags.DYEABLE hinzufügen, um es in deinem Inventar färben zu können!
Bedingt
Als Nächstes werden wir uns mit der Erstellung von Itemmodellen befassen, deren Darstellung sich ändert, wenn eine bestimmte Bedingung erfüllt ist, die durch den zweiten Parameter BooleanProperty angegeben wird. Hier sind einige davon:
| Eigenschaft | Beschreibung |
|---|---|
IsKeybindDown | Wahr, wenn eine bestimmte Taste gedrückt wird. |
IsUsingItem | Wahr, wenn das Item verwendet wird (z. B. beim Blocken mit einem Schild). |
Broken | Wahr, wenn das Item eine Haltbarkeit von 0 hat (z. B. ändert die Elytra die Textur, wenn sie zerbrochen ist). |
HasComponent | Wahr, wenn das Item eine bestimmte Komponente enthält. |
Der dritte und vierte Parameter sind die Modelle, die verwendet werden sollen, wenn die Eigenschaft true oder false ist.
java
itemModelGenerator.generateBooleanDispatch(
ModItems.FLASHLIGHT,
ItemModelUtils.isUsingItem(),
ItemModelUtils.plainModel(itemModelGenerator.createFlatItemModel(ModItems.FLASHLIGHT, "_lit", ModelTemplates.FLAT_ITEM)),
ItemModelUtils.plainModel(itemModelGenerator.createFlatItemModel(ModItems.FLASHLIGHT, ModelTemplates.FLAT_ITEM))
);1
2
3
4
5
6
2
3
4
5
6
WICHTIG
Um den in ItemModelUtils.plainModel() übergebenen Identifier zu erhalten, verwende immer itemModelGenerator.createFlatItemModel(), da sonst nur die Client Items generiert werden, nicht jedoch die Itemmodelle!
Zusammensetzung
Zusammengesetzte Itemmodelle bestehen aus einer oder mehreren Texturen, die übereinander gelegt sind. Dafür gibt es keine Vanilla Methoden; du musst das Feld itemModelOutput des itemModelGenerator verwenden und accept() darauf aufrufen.
java
ItemModel.Unbaked hoe = ItemModelUtils.plainModel(itemModelGenerator.createFlatItemModel(ModItems.ENHANCED_HOE, ModelTemplates.FLAT_ITEM));
ItemModel.Unbaked hoePlus = ItemModelUtils.plainModel(itemModelGenerator.createFlatItemModel(ModItems.ENHANCED_HOE, "_plus", ModelTemplates.FLAT_ITEM));
itemModelGenerator.itemModelOutput.accept(
ModItems.ENHANCED_HOE,
ItemModelUtils.composite(hoe, hoePlus)
);1
2
3
4
5
6
7
2
3
4
5
6
7
Auswahl
Rendert ein Itemmodell basierend auf dem Wert einer bestimmten Eigenschaft. Dies sind einige davon:
| Eigenschaft | Beschreibung |
|---|---|
ContextDimension | Rendert ein Itemmodell basierend auf der Dimension, in der sich der Spieler befindet (Oberwelt, Nether, End). |
MainHand | Rendert ein Itemmodell, wenn das Item in der Haupthand des Spielers ausgerüstet ist. |
DisplayContext | Rendert ein Itemmodell basierend auf der Position des Objekts (ground, fixed, head, ...). |
ContextEntityType | Rendert ein Itemmodell basierend auf der Entität, die das Item hält. |
In diesem Beispiel ändert das Item seine Textur beim Wechsel zwischen den Dimensionen: In der Oberwelt ist es grün, im Nether rot und im End schwarz.
java
ItemModel.Unbaked crystalOverworld = ItemModelUtils.plainModel(itemModelGenerator.createFlatItemModel(ModItems.DIMENSIONAL_CRYSTAL, "_overworld", ModelTemplates.FLAT_ITEM));
ItemModel.Unbaked crystalNether = ItemModelUtils.plainModel(itemModelGenerator.createFlatItemModel(ModItems.DIMENSIONAL_CRYSTAL, "_nether", ModelTemplates.FLAT_ITEM));
ItemModel.Unbaked crystalEnd = ItemModelUtils.plainModel(itemModelGenerator.createFlatItemModel(ModItems.DIMENSIONAL_CRYSTAL, "_end", ModelTemplates.FLAT_ITEM));
itemModelGenerator.itemModelOutput.accept(
ModItems.DIMENSIONAL_CRYSTAL,
ItemModelUtils.select(new ContextDimension(),
ItemModelUtils.when(Level.OVERWORLD, crystalOverworld),
ItemModelUtils.when(Level.NETHER, crystalNether),
ItemModelUtils.when(Level.END, crystalEnd)
)
);1
2
3
4
5
6
7
8
9
10
11
12
2
3
4
5
6
7
8
9
10
11
12
Reichweiten Erweiterung
Rendert ein Itemmodell basierend auf dem Wert einer numerischen Eigenschaft. Nimmt ein Item und eine Liste von Varianten entgegen, die jeweils mit einem Wert gepaart sind. Beispiele hierfür sind der Kompass, der Bogen und der Pinsel.
Es gibt eine ganze Reihe unterstützter Eigenschaften, hier einige Beispiele:
| Eigenschaft | Beschreibung |
|---|---|
Cooldown | Rendert ein Itemmodell basierend auf der verbleibenden Abklingzeit des Items. |
Count | Rendert ein Itemmodell basierend auf der Stack-Größe. |
UseDuration | Rendert ein Itemmodell basierend darauf, wie lange das Item verwendet wird. |
Damage | Rendert ein Itemmodell basierend auf dem Angriffsschaden (Komponente minecraft:damage). |
In diesem Beispiel wird Count verwendet, um die Textur je nach Stackgröße von einem Messer auf bis zu drei Messer zu ändern.
java
ItemModel.Unbaked knifeOne = ItemModelUtils.plainModel(itemModelGenerator.createFlatItemModel(ModItems.THROWING_KNIVES, "_one", ModelTemplates.FLAT_ITEM));
ItemModel.Unbaked knifeTwo = ItemModelUtils.plainModel(itemModelGenerator.createFlatItemModel(ModItems.THROWING_KNIVES, "_two", ModelTemplates.FLAT_ITEM));
ItemModel.Unbaked knifeThree = ItemModelUtils.plainModel(itemModelGenerator.createFlatItemModel(ModItems.THROWING_KNIVES, "_three", ModelTemplates.FLAT_ITEM));
itemModelGenerator.itemModelOutput.accept(
ModItems.THROWING_KNIVES,
ItemModelUtils.rangeSelect(
new Count(false),
List.of(
ItemModelUtils.override(knifeOne, 1.0F),
ItemModelUtils.override(knifeTwo, 2.0F),
ItemModelUtils.override(knifeThree, 3.0F)
)
)
);1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Benutzerdefinierte Itemmodelle
Generierung von Itemmodellen muss nicht nur mit Standardmethoden erfolgen; du kannst natürlich auch deine eigenen erstellen. In diesem Abschnitt erstellen wir ein benutzerdefiniertes Modell für ein Ballon Item.
Alle Felder und Methoden für diesen Teil des Tutorials werden in einer statischen inneren Klasse mit dem Namen CustomItemModelGenerator deklariert.
Zeige CustomItemModelGenerator
java
public static class CustomItemModelGenerator {
//:::custom-item-model:::
public static final ModelTemplate SCALED2X = item("scaled2x", TextureSlot.LAYER0);
//:::custom-item-model:::
//:::custom-item-datagen-method
public static void registerScaled2x(Item item, ItemModelGenerators generator) {
Identifier itemModel = SCALED2X.create(item, TextureMapping.singleSlot(TextureSlot.LAYER0, ModelLocationUtils.getModelLocation(item)), generator.modelOutput);
generator.itemModelOutput.accept(item, ItemModelUtils.plainModel(itemModel));
}
//:::custom-item-datagen-method
@SuppressWarnings("SameParameterValue")
//:::custom-item-model:::
private static ModelTemplate item(String parent, TextureSlot requiredTextureKeys) {
return new ModelTemplate(Optional.of(Identifier.fromNamespaceAndPath(ExampleMod.MOD_ID, "item/" + parent)), Optional.empty(), requiredTextureKeys);
}
//:::custom-item-model:::
}1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
Erstellen eines benutzerdefinierten übergeordneten Itemmodell
Zunächst erstellen wir ein übergeordnetes Itemmodell, das definiert, wie das Item im Spiel aussieht. Nehmen wir an, wir möchten, dass der Ballon wie einfache Itemmodelle aussieht, jedoch hoch skaliert.
Dazu erstellen wir die Datei resources/assets/example-mod/models/item/scaled2x.json, legen als übergeordnetes Modell item/generated fest und überschreiben dann die Skalierung.
json
{
"parent": "item/generated",
"display": {
"ground": {
"rotation": [0, 0, 0],
"translation": [0, 2, 0],
"scale": [1, 1, 1]
},
"head": {
"rotation": [0, 180, 0],
"translation": [0, 13, 7],
"scale": [2, 2, 2]
},
"thirdperson_righthand": {
"rotation": [0, 0, 0],
"translation": [0, 3, 1],
"scale": [1.1, 1.1, 1.1]
},
"firstperson_righthand": {
"rotation": [0, -90, 25],
"translation": [1.13, 3.2, 1.13],
"scale": [1.36, 1.36, 1.36]
}
}
}1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
Dadurch wird das Modell visuell doppelt so groß wie die einfachen Modelle.
Das ModelTemplate erstellen
Als Nächstes müssen wir eine Instanz der Klasse ModelTemplate erstellen. Sie wird das tatsächliche übergeordnete Itemmodell in unserem Mod repräsentieren.
java
public static final ModelTemplate SCALED2X = item("scaled2x", TextureSlot.LAYER0);
private static ModelTemplate item(String parent, TextureSlot requiredTextureKeys) {
return new ModelTemplate(Optional.of(Identifier.fromNamespaceAndPath(ExampleMod.MOD_ID, "item/" + parent)), Optional.empty(), requiredTextureKeys);
}1
2
3
4
5
6
2
3
4
5
6
Die Methode item() erstellt eine neue Instanz von ModelTemplate, die auf die zuvor erstellte Datei scaled2x.json verweist.
Textur-Slot LAYER0 repräsentiert die Texturvariable #layer0, welche dann durch einen Bezeichner ersetzt wird, der auf eine Textur verweist.
Hinzufügen einer benutzdefinierten Methode für den Datengenerator
Der letzte Schritt besteht darin, eine benutzerdefinierte Methode zu erstellen, die in der Methode generateItemModels() aufgerufen wird und für die Generierung unserer Itemmodelle zuständig ist.
java
public static void registerScaled2x(Item item, ItemModelGenerators generator) {
Identifier itemModel = SCALED2X.create(item, TextureMapping.singleSlot(TextureSlot.LAYER0, ModelLocationUtils.getModelLocation(item)), generator.modelOutput);
generator.itemModelOutput.accept(item, ItemModelUtils.plainModel(itemModel));
}1
2
3
4
5
2
3
4
5
Lasst uns durchgehen, wofür die Parameter stehen:
Item item: Das Item, für welches wir die Modelle generieren.ItemModelGenerators generator: Das Selbe, das an die MethodegenerateItemModels()übergeben wird. Wird für dessen Felder verwendet.
Zuerst erhalten wir den Identifier des Items mit SCALED2X.create(), wobei wir ein TextureMapping und den modelOutput aus unserem Parameter generator übergeben.
Dann verwenden wir ein weiteres Feld, den itemModelOutput (das im Wesentlichen als Consumer dient), und verwenden die Methode accept(), damit die Modelle tatsächlich generiert werden.
Die benutzdefinierte Methode aufrufen
Jetzt müssen wir nur noch unsere Methode in der Methode generateItemModels() aufrufen.
java
CustomItemModelGenerator.registerScaled2x(ModItems.BALLOON, itemModelGenerator);1
Vergiss nicht, eine Texturdatei hinzuzufügen!
Quellen und Links
Weitere Informationen findest du in den Beispiel-Tests in der Fabric API und im Beispiel Mod dieser Dokumentation.





