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:

1. Ein Itemmodell, das die Texturen, die Drehung und das allgemeine Aussehen des Items definiert. Es wird im Verzeichnis generated/assets/example-mod/models/item abgelegt.
2. 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/items abgelegt.

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.

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";
	}
}

Registriere diese Klasse in deinem DataGeneratorEntrypoint innerhalb der Methode onInitializeDataGenerator.

pack.addProvider(ExampleModModelProvider::new);

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.

itemModelGenerator.generateFlatItem(ModItems.RUBY, ModelTemplates.FLAT_ITEM);

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.

itemModelGenerator.generateFlatItem(ModItems.GUIDITE_AXE, ModelTemplates.FLAT_HANDHELD_ITEM);

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.

itemModelGenerator.generateDyedItem(ModItems.LEATHER_GLOVES, 0xFFA06540);

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.

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))
);

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.

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)
);

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.

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)
				)
);

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.

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)
								)
				)
);

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

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:::
}

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.

{
  "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]
    }
  }
}

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.

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);
}

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.

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));
}

Lasst uns durchgehen, wofür die Parameter stehen:

1. Item item: Das Item, für welches wir die Modelle generieren.
2. ItemModelGenerators generator: Das Selbe, das an die Methode generateItemModels() ü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.

CustomItemModelGenerator.registerScaled2x(ModItems.BALLOON, itemModelGenerator);

Vergiss nicht, eine Texturdatei hinzuzufügen!

Ballon Textur herunterladen

Quellen und Links

Weitere Informationen findest du in den Beispiel-Tests in der Fabric API und im Beispiel Mod dieser Dokumentation.