diff --git a/translated/de_de/develop/data-generation/block-models.md b/translated/de_de/develop/data-generation/block-models.md new file mode 100644 index 000000000..439f87c4e --- /dev/null +++ b/translated/de_de/develop/data-generation/block-models.md @@ -0,0 +1,216 @@ +--- +title: Generation von Blockmodellen +description: Ein Leitfaden zur Generierung von Blockmodellen und Blockzuständen mit dem Datengenerator. +authors: + - Fellteros + - natri0 + - IMB11 + - its-miroma +--- + +# Generation von Blockmodellen {#block-model-generation} + +:::info VORAUSSETZUNGEN +Stelle sicher, dass du den Prozess der [Einrichtung der Datengenerierung](./setup) zuerst abgeschlossen hast. +::: + +## Einrichten {#setup} + +Zuerst müssen wir unseren ModelProvider erstellen. Erstelle eine Klasse, welche `extends FabricModelProvider`. Implementiere beide abstrakten Methoden: `generateBlockStateModels` und `generateItemModels`. +Zum Schluss, erstelle einen Konstruktor, der zu super passt. + +@[code lang=java transcludeWith=:::datagen-model:provider](@/reference/latest/src/client/java/com/example/docs/datagen/FabricDocsReferenceModelProvider.java) + +Registriere diese Klasse in deinem `DataGeneratorEntrypoint` innerhalb der `onInitializeDataGenerator`-Methode. + +## Blockzustände und Blockmodelle {#blockstates-and-block-models} + +```java +@Override +public void generateBlockStateModels(BlockStateModelGenerator blockStateModelGenerator) { +} +``` + +Für Blockmodelle werden wir uns hauptsächlich auf die `generateBlockStateModels`-Methode fokusieren. Beachte den Parameter `BlockStateModelGenerator blockStateModelGenerator` - dieses Objekt wird für die Generierung aller JSON-Dateien verantwortlich sein. +Hier sind einige praktische Beispiele, die du zur Generierung deiner gewünschten Modelle verwenden kannst: + +### Einfacher Cube All {#simple-cube-all} + +@[code lang=java transcludeWith=:::datagen-model:cube-all](@/reference/latest/src/client/java/com/example/docs/datagen/FabricDocsReferenceModelProvider.java) + +Dies ist die am häufigsten verwendete Funktion. Sie generiert eine JSON-Modell-Datei für ein normales `cube_all` Blockmodell. Eine Textur wird für alle sechs Seiten genutzt, in diesem Fall nutzen wir `steel_block`. + +@[code](@/reference/latest/src/main/generated/assets/fabric-docs-reference/models/block/steel_block.json) + +Sie generiert auch eine Blockzustand-JSON-Datei. Da wir keine Blockzustand-Eigenschaften (z. B. Achsen, Ausrichtung, ...) haben, ist eine Variante ausreichend und wird jedes Mal verwendet, wenn der Block platziert wird. + +@[code](@/reference/latest/src/main/generated/assets/fabric-docs-reference/blockstates/steel_block.json) + +Stahlblock + +### Singletons {#singletons} + +Die `registerSingleton`-Methode liefert JSON-Modelldateien basierend auf dem übergebenen `TexturedModel` und einer einzelnen Blockzustand-Variante. + +@[code lang=java transcludeWith=:::datagen-model:cube-top-for-ends](@/reference/latest/src/client/java/com/example/docs/datagen/FabricDocsReferenceModelProvider.java) + +Diese Methode wird Modelle für einen normalen Würfel generieren, der die Texturdatei `pipe_block` für die Seiten und die Texturdatei `pipe_block_top` für die obere und untere Seite nutzt. + +@[code](@/reference/latest/src/main/generated/assets/fabric-docs-reference/models/block/pipe_block.json) + +:::tip +Wenn du dich nicht entscheiden kannst, welches `TextureModel` du verwenden sollst, öffne die Klasse `TexturedModel` und sieh dir die [`TextureMaps`](#using-texture-map) an! +::: + +Rohrblock + +### Block-Textur-Pool {#block-texture-pool} + +@[code lang=java transcludeWith=:::datagen-model:block-texture-pool-normal](@/reference/latest/src/client/java/com/example/docs/datagen/FabricDocsReferenceModelProvider.java) + +Eine andere nützliche Methode ist `registerCubeAllModelTexturePool`: Definiere die Texturen, indem du den "Basisblock" übergibst, und füge dann die "Kinder" hinzu, die die gleichen Texturen haben. +In diesem Fall haben wir den `RUBY_BLOCK` übergeben, so dass die Treppe, die Stufe und der Zaun die Textur `RUBY_BLOCK` verwenden werden. + +:::warning +Sie wird auch ein [einfaches Cube All JSON-Modell](#simple-cube-all) für den "Basisblock" generieren, um sicherzustellen, dass er ein Blockmodell hat. + +Sei dir dessen bewusst, wenn du das Blockmodell dieses bestimmten Blocks änderst, da dies zu einem Fehler führen wird. +::: + +Du kannst auch eine `BlockFamily` anhängen, die Modelle für alle ihre "Kinder" generieren wird. + +@[code lang=java transcludeWith=:::datagen-model:family-declaration](@/reference/latest/src/main/java/com/example/docs/block/ModBlocks.java) + +@[code lang=java transcludeWith=:::datagen-model:block-texture-pool-family](@/reference/latest/src/client/java/com/example/docs/datagen/FabricDocsReferenceModelProvider.java) + +Rubinblock + +### Türen und Falltüren {#doors-and-trapdoors} + +@[code lang=java transcludeWith=:::datagen-model:door-and-trapdoor](@/reference/latest/src/client/java/com/example/docs/datagen/FabricDocsReferenceModelProvider.java) + +Türen und Falltüren sein ein wenig anders. Hier musst du drei neue Texturen erstellen - zwei für die Türe, und eine für die Falltüre. + +1. Die Tür: + - Sie hat zwei Teile - die obere und die untere Hälfte. **Jede benötigt ihre eigene Textur:** In diesem Fall `ruby_door_top` für die obere und `ruby_door_bottom` für die untere Hälfte. + - Die Methode `registerDoor()` wird Modelle für alle Ausrichtungen der Tür, sowohl offen als auch geschlossen erstellen. + - **Du benötigst auch eine Itemtextur!** Lege sie in dem Ordner `assets//textures/item/` ab. +2. Die Falltür: + - Hier benötigst du nur eine Textur, die in diesem Fall `ruby_trapdoor` heißt. Diese wird für alle Seiten genutzt. + - Da `TrapdoorBlock` eine Eigenschaft `FACING` hat, kannst du die auskommentierte Methode verwenden, um Modell-Dateien mit rotierten Texturen zu generieren = Die Falltüre wird "orientierbar" sein. Andernfalls sieht sie immer gleich aus, egal in welche Richtung sie gerichtet ist. + +Rubintür und Falltür + +## Benutzerdefinierte Blockmodelle {#custom-block-models} + +In diesem Abschnitt werden wir die Modelle für eine vertikale Eichenstammstufe, mit einer Eichenstamm-Textur, erstellen. + +_Punkte 2. - 6. werden in einer inneren, statischen Hilfsklasse namens `CustomBlockStateModelGenerator` deklariert._ + +### Benutzerdefinierte Blockklasse {#custom-block-class} + +Erstelle einen Block `VerticalSlab` mit einer Eigenschaft `FACING` und einer boolean-Eigenschaft `SINGLE`, wie in dem Tutorial [Block States](../blocks/blockstates) beschrieben. `SINGLE` zeigt an, ob beide Stufen sind. +Dann solltest du `getOutlineShape` und `getCollisionShape` überschreiben, so dass die Umrandung korrekt gerendert wird und der Block die richtige Kollisionsform hat. + +@[code lang=java transcludeWith=:::datagen-model-custom:voxels](@/reference/latest/src/main/java/com/example/docs/block/custom/VerticalSlabBlock.java) + +@[code lang=java transcludeWith=:::datagen-model-custom:collision](@/reference/latest/src/main/java/com/example/docs/block/custom/VerticalSlabBlock.java) + +Überschreibe auch die Methode `canReplace()`, sonst kannst du die Stufe nicht zu einem vollen Block machen. + +@[code lang=java transcludeWith=:::datagen-model-custom:replace](@/reference/latest/src/main/java/com/example/docs/block/custom/VerticalSlabBlock.java) + +Und du bist fertig! Du kannst jetzt den Block austesten und im Spiel platzieren. + +### Übergeordnetes Blockmodell {#parent-block-model} + +Lasst und jetzt ein übergeordnetes Blockmodell erstellen. Es bestimmt die Größe, Position in der Hand oder in anderen Slots und die `x` und `y` Koordinaten der Textur. +Es wird empfohlen für dies einen Editor, wie [Blockbench](https://www.blockbench.net/) zu verwenden, da die manuelle Erstellung ein wirklich mühsamer Prozess ist. Es sollte wie folgt aussehen: + +@[code lang=json](@/reference/latest/src/main/resources/assets/fabric-docs-reference/models/block/vertical_slab.json) + +Für weitere Informationen, siehe dir an [wie Blockzustände formatiert sind](https://minecraft.wiki/w/Blockstates_definition_format). +Beachte die Schlüsselwörter `#bottom`, `#top`, `#side`. Sie dienen als Variablen, die von Modellen gesetzt werden können, die dieses Modell als übergeordnetes Modell haben: + +```json +{ + "parent": "minecraft:block/cube_bottom_top", + "textures": { + "bottom": "minecraft:block/sandstone_bottom", + "side": "minecraft:block/sandstone", + "top": "minecraft:block/sandstone_top" + } +} +``` + +Der Wert `bottom` wird den Platzhalter `#bottom` ersetzen und so weiter. **Füge es in den Ordner `resources/assets/mod_id/models/block/` ein.** + +### Benutzerdefiniertes Modell {#custom-model} + +Eine weitere Sache, die wir benötigen, ist eine Instanz der Klasse `Model`. Sie wird das tatsächliche [übergeordnete Blockmodell](#parent-block-model) in unserem Mod repräsentieren. + +@[code lang=java transcludeWith=:::datagen-model-custom:model](@/reference/latest/src/client/java/com/example/docs/datagen/FabricDocsReferenceModelProvider.java) + +Die Methode `block()` erstellt ein neues `Model`, das auf die Datei `vertical_slab.json` in unserem Ordner `resources/assets/mod_id/models/block/` zeigt. +Die `TextureKey`s repräsentieren die "Platzhalter" (`#bottom`, `#top`, ...) als ein Objekt. + +### Die Texture Map verwenden {#using-texture-map} + +Was macht die `TextureMap`? Sie liefert die Identifikatoren, die auf die Textur verweisen. Technisch gesehen verhält sie sich wie eine normale Map - man verbindet einen `TextureKey` (Schlüssel) mit einem `Identifier` (Wert). + +Du kannst entweder die von Vanilla verwenden, wie `TextureMap.all()` (die alle TextureKeys mit dem selben Identifikator verknüpft), oder eine neue erstellen, indem du eine neue Instanz erstellst und dann `.put()` aufrufst, um die Schlüssel mit Werten zu verknüpfen. + +:::tip +`TextureMap.all()` verknüpft alle TextureKeys mit dem selben Identifikator, egal wie viele es davon gibt! +::: + +Da wir die Eichenstammtexturen nutzen wollen, aber die `BOTTOM`, `TOP` und `SIDE` `TextureKey`s haben, müssen wir eine neue erstellen. + +@[code lang=java transcludeWith=:::datagen-model-custom:texture-map](@/reference/latest/src/client/java/com/example/docs/datagen/FabricDocsReferenceModelProvider.java) + +Die `bottom` und `top` Flächen werden `oak_log_top.png` verwenden, die Seiten werden `oak_log.png` verwenden. + +:::warning +Alle `TextureKey`s in deiner TextureMap **müssen** mit den `TextureKey`s in deinem übergeordneten Blockmodell übereinstimmen! +::: + +### Benutzerdefinierte `BlockStateSupplier`-Methode {#custom-supplier-method} + +Der `BlockStateSupplier` beinhaltet alle Varianten an Blockzuständen, deren Rotation und anderen Optionen, wie uvlock. + +@[code lang=java transcludeWith=:::datagen-model-custom:supplier](@/reference/latest/src/client/java/com/example/docs/datagen/FabricDocsReferenceModelProvider.java) + +Zuerst erstellen wir einen neuen `VariantsBlockStateSupplier` mit Hilfe von `VariantsBlockStateSupplier.create()`. +Dann erstellen wir eine neue `BlockStateVariantMap`, die Parameter für alle Varianten des Blocks beinhaltet, in diesem Fall `FACING` und `SINGLE` und übergeben diese in den `VariantsBlockStateSupplier`. +Gebe an, welches Modell und welche Transformation (uvlock, rotation) bei der Verwendung von `.register()` genutzt wird. +Zum Beispiel: + +- In der ersten Zeile, zeigt der Block nach Norden und ist einzeln => Wir verwenden das Modell ohne Rotation. +- In der vierten Zeile, zeigt der Block nach Westen und ist einzeln => Wir rotieren das Modell auf der Y-Achse für 270°. +- In der sechsten Zeile, zeigt der Block nach Osten, ist jedoch nicht einzeln => Er sieht aus wie ein normaler Eichenstamm => Wie müssen ihn nicht rotieren. + +### Benutzerdefinierte Methode für den Datengenerator {#custom-datagen-method} + +Der letzte Schritt - die Erstellung der tatsächlichen Methode, die du aufrufen kannst und die die JSONs generiert. +Aber für was sind die Parameter? + +1. `BlockStateModelGenerator generator`, das gleiche, dass wir an `generateBlockStateModels` übergeben haben. +2. `Block vertSlabBlock` ist der Block, zu dem wir die JSONs generieren werden. +3. `Block fullBlock` - ist das Modell, dass genutzt wird, wenn die Eigenschaft `SINGLE` false ist = der Stufenblock sieht wie ein voller Block aus. +4. `TextureMap textures` definiert die tatsächlichen Texturen, die das Modell nutzt. Siehe das Kapitel [Die Texture Map nutzen verwenden](#using-texture-map). + +@[code lang=java transcludeWith=:::datagen-model-custom:gen](@/reference/latest/src/client/java/com/example/docs/datagen/FabricDocsReferenceModelProvider.java) + +Zunächst erhalten wir den `Identifier` des einzelnen Stufenmodell mit `VERTICAL_SLAB.upload()`. Dann erhalten wir den `Identifier` des vollen Blockmodells mit `ModelIds.getBlockModelId()`, und übergeben diese beiden Modelle an `createVerticalSlabBlockStates`. +Der `BlockStateSupplier` wird an den `blockStateCollector` übergeben, so dass die JSON-Dateien tatsächlich generiert werden. +Außerdem, erstellen wir ein Modell für das Item der vertikalen Stufe mit BlockStateModelGenerator.registerParentedItemModel()\`. + +Und dies ist alles! Jetzt müssen wir nur noch unsere Methode in unserem `ModelProvider` aufrufen: + +@[code lang=java transcludeWith=:::datagen-model-custom:method-call](@/reference/latest/src/client/java/com/example/docs/datagen/FabricDocsReferenceModelProvider.java) + +## Quellen und Links {#sources-and-links} + +Du kannst für weitere Informationen die Beispieltests in der [Fabric API](https://github.com/FabricMC/fabric/blob/1.21.4/fabric-data-generation-api-v1/src/) und im [Referenz-Mod](https://github.com/FabricMC/fabric-docs/tree/main/reference) dieser Dokumentation ansehen. + +Du kannst auch weitere Beispiele für die Verwendung von benutzerdefinierten Methoden für den Datengenerator finden, indem du den Open-Source-Code von Mods durchsuchst, zum Beispiel [Vanilla+ Blocks](https://github.com/Fellteros/vanillablocksplus) und [Vanilla+ Verticals](https://github.com/Fellteros/vanillavsplus) von Fellteros.