Generation von Blockmodellen 1.21.4

Ein Leitfaden zur Generierung von Blockmodellen und Blockzuständen mit dem Datengenerator.

WARNING

Diese Seite ist für die Version 1.21.4 geschrieben. Dokumentationen für ältere Versionen sind möglicherweise unvollständig.

VORAUSSETZUNGEN

Stelle sicher, dass du den Prozess der Einrichtung der Datengenerierung zuerst abgeschlossen hast.

Einrichten

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.

public class FabricDocsReferenceModelProvider extends FabricModelProvider {
	public FabricDocsReferenceModelProvider(FabricDataOutput output) {
		super(output);
	}

	@Override
	public void generateBlockStateModels(BlockModelGenerators blockStateModelGenerator) {
	}


	@Override
	public void generateItemModels(ItemModelGenerators itemModelGenerator) {
	}

	@Override
	public String getName() {
		return "FabricDocsReference Model Provider";
	}
}

Registriere diese Klasse in deinem DataGeneratorEntrypoint innerhalb der onInitializeDataGenerator-Methode.

Blockzustände und Blockmodelle

@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

blockStateModelGenerator.createTrivialCube(ModBlocks.STEEL_BLOCK);

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.

{
  "parent": "minecraft:block/cube_all",
  "textures": {
    "all": "fabric-docs-reference:block/steel_block"
  }
}

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.

{
  "variants": {
    "": {
      "model": "fabric-docs-reference:block/steel_block"
    }
  }
}

Stahlblock herunterladen

Singletons

Die registerSingleton-Methode liefert JSON-Modelldateien basierend auf dem übergebenen TexturedModel und einer einzelnen Blockzustand-Variante.

blockStateModelGenerator.createTrivialBlock(ModBlocks.PIPE_BLOCK, TexturedModel.COLUMN_ALT);

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.

{
  "parent": "minecraft:block/cube_column",
  "textures": {
    "end": "fabric-docs-reference:block/pipe_block_top",
    "side": "fabric-docs-reference:block/pipe_block"
  }
}

TIP

Wenn du dich nicht entscheiden kannst, welches TextureModel du verwenden sollst, öffne die Klasse TexturedModel und sieh dir die TextureMaps an!

Rohrblock herunterladen

Block-Textur-Pool

blockStateModelGenerator.family(ModBlocks.RUBY_BLOCK)
		.stairs(ModBlocks.RUBY_STAIRS)
		.slab(ModBlocks.RUBY_SLAB)
		.fence(ModBlocks.RUBY_FENCE);

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 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.

public static final BlockFamily RUBY_FAMILY =
		new BlockFamily.Builder(ModBlocks.RUBY_BLOCK)
		.stairs(ModBlocks.RUBY_STAIRS)
		.slab(ModBlocks.RUBY_SLAB)
		.fence(ModBlocks.RUBY_FENCE)
		.getFamily();

blockStateModelGenerator.family(ModBlocks.RUBY_BLOCK).generateFor(ModBlocks.RUBY_FAMILY);

Rubinblock herunterladen

Türen und Falltüren

blockStateModelGenerator.createDoor(ModBlocks.RUBY_DOOR);
blockStateModelGenerator.createTrapdoor(ModBlocks.RUBY_TRAPDOOR);
// blockStateModelGenerator.registerOrientableTrapdoor(ModBlocks.RUBY_TRAPDOOR);

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/<mod_id>/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 herunterladen

Benutzerdefinierte Blockklasse

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 Blockmodelle

Erstelle einen Block VerticalSlab mit einer Eigenschaft FACING und einer boolean-Eigenschaft SINGLE, wie in dem Tutorial Block States 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.

public static final VoxelShape NORTH_SHAPE = Block.box(0.0, 0.0, 0.0, 16.0, 16.0, 8.0);
public static final VoxelShape SOUTH_SHAPE = Block.box(0.0, 0.0, 8.0, 16.0, 16.0, 16.0);
public static final VoxelShape WEST_SHAPE = Block.box(0.0, 0.0, 0.0, 8.0, 16.0, 16.0);
public static final VoxelShape EAST_SHAPE = Block.box(8.0, 0.0, 0.0, 16.0, 16.0, 16.0);

@Override
protected VoxelShape getBlockSupportShape(BlockState state, BlockGetter world, BlockPos pos) {
	boolean type = state.getValue(SINGLE);
	Direction direction = state.getValue(FACING);
	VoxelShape voxelShape;

	if (type) {
		switch (direction) {
			case WEST -> voxelShape = WEST_SHAPE.singleEncompassing();
			case EAST -> voxelShape = EAST_SHAPE.singleEncompassing();
			case SOUTH -> voxelShape = SOUTH_SHAPE.singleEncompassing();
			case NORTH -> voxelShape = NORTH_SHAPE.singleEncompassing();
			default -> throw new MatchException(null, null);
		}

		return voxelShape;
	} else {
		return Shapes.block();
	}
}

@Override
protected VoxelShape getShape(BlockState state, BlockGetter world, BlockPos pos, CollisionContext context) {
	return this.getBlockSupportShape(state, world, pos);
}

@Override
protected VoxelShape getCollisionShape(BlockState state, BlockGetter world, BlockPos pos, CollisionContext context) {
	return this.getBlockSupportShape(state, world, pos);
}

Überschreibe auch die Methode canReplace(), sonst kannst du die Stufe nicht zu einem vollen Block machen.

@Override
protected boolean canBeReplaced(BlockState state, BlockPlaceContext context) {
	Direction direction = state.getValue(FACING);

	if (context.getItemInHand().is(this.asItem()) && state.getValue(SINGLE)) {
		if (context.replacingClickedOnBlock()) {
			return context.getClickedFace().getOpposite() == direction;
		}
	}

	return false;
}

Und du bist fertig! Du kannst jetzt den Block austesten und im Spiel platzieren.

Übergeordnetes Blockmodell

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 zu verwenden, da die manuelle Erstellung ein wirklich mühsamer Prozess ist. Es sollte wie folgt aussehen:

{
  "parent": "minecraft:block/block",
  "textures": {
    "particle": "#side"
  },
  "display": {
    "gui": {
      "rotation": [
        30,
        -135,
        0
      ],
      "translation": [
        -1.5,
        0.75,
        0
      ],
      "scale": [
        0.625,
        0.625,
        0.625
      ]
    },
    "firstperson_righthand": {
      "rotation": [
        0,
        -45,
        0
      ],
      "translation": [
        0,
        2,
        0
      ],
      "scale": [
        0.375,
        0.375,
        0.375
      ]
    },
    "firstperson_lefthand": {
      "rotation": [
        0,
        315,
        0
      ],
      "translation": [
        0,
        2,
        0
      ],
      "scale": [
        0.375,
        0.375,
        0.375
      ]
    },
    "thirdperson_righthand": {
      "rotation": [
        75,
        -45,
        0
      ],
      "translation": [
        0,
        0,
        2
      ],
      "scale": [
        0.375,
        0.375,
        0.375
      ]
    },
    "thirdperson_lefthand": {
      "rotation": [
        75,
        315,
        0
      ],
      "translation": [
        0,
        0,
        2
      ],
      "scale": [
        0.375,
        0.375,
        0.375
      ]
    }
  },
  "elements": [
    {
      "from": [
        0,
        0,
        0
      ],
      "to": [
        16,
        16,
        8
      ],
      "faces": {
        "down": {
          "uv": [
            0,
            8,
            16,
            16
          ],
          "texture": "#bottom",
          "cullface": "down",
          "tintindex": 0
        },
        "up": {
          "uv": [
            0,
            0,
            16,
            8
          ],
          "texture": "#top",
          "cullface": "up",
          "tintindex": 0
        },
        "north": {
          "uv": [
            0,
            0,
            16,
            16
          ],
          "texture": "#side",
          "cullface": "north",
          "tintindex": 0
        },
        "south": {
          "uv": [
            0,
            0,
            16,
            16
          ],
          "texture": "#side",
          "tintindex": 0
        },
        "west": {
          "uv": [
            0,
            0,
            8,
            16
          ],
          "texture": "#side",
          "cullface": "west",
          "tintindex": 0
        },
        "east": {
          "uv": [
            8,
            0,
            16,
            16
          ],
          "texture": "#side",
          "cullface": "east",
          "tintindex": 0
        }
      }
    }
  ]
}

Für weitere Informationen, siehe dir an wie Blockzustände formatiert sind. 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:

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

Eine weitere Sache, die wir benötigen, ist eine Instanz der Klasse Model. Sie wird das tatsächliche übergeordnete Blockmodell in unserem Mod repräsentieren.

public static final ModelTemplate VERTICAL_SLAB = block("vertical_slab", TextureSlot.BOTTOM, TextureSlot.TOP, TextureSlot.SIDE);

//helper method for creating Models
private static ModelTemplate block(String parent, TextureSlot... requiredTextureKeys) {
	return new ModelTemplate(Optional.of(ResourceLocation.fromNamespaceAndPath(FabricDocsReference.MOD_ID, "block/" + parent)), Optional.empty(), requiredTextureKeys);
}

//helper method for creating Models with variants
private static ModelTemplate block(String parent, String variant, TextureSlot... requiredTextureKeys) {
	return new ModelTemplate(Optional.of(ResourceLocation.fromNamespaceAndPath(FabricDocsReference.MOD_ID, "block/" + parent)), Optional.of(variant), requiredTextureKeys);
}

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 TextureKeys repräsentieren die "Platzhalter" (#bottom, #top, ...) als ein Objekt.

Die Texture Map verwenden

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 ResourceLocation (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 TextureKeys haben, müssen wir eine neue erstellen.

public static TextureMapping blockAndTopForEnds(Block block) {
	return new TextureMapping()
			.put(TextureSlot.TOP, ModelLocationUtils.getModelLocation(block, "_top"))
			.put(TextureSlot.BOTTOM, ModelLocationUtils.getModelLocation(block, "_top"))
			.put(TextureSlot.SIDE, ModelLocationUtils.getModelLocation(block));
}

Die bottom und top Flächen werden oak_log_top.png verwenden, die Seiten werden oak_log.png verwenden.

WARNING

Alle TextureKeys in deiner TextureMap müssen mit den TextureKeys in deinem übergeordneten Blockmodell übereinstimmen!

Benutzerdefinierte BlockStateSupplier-Methode

Der BlockStateSupplier beinhaltet alle Varianten an Blockzuständen, deren Rotation und anderen Optionen, wie uvlock.

private static BlockStateGenerator createVerticalSlabBlockStates(Block vertSlabBlock, ResourceLocation vertSlabId, ResourceLocation fullBlockId) {
	VariantProperty<Boolean> uvlock = VariantProperties.UV_LOCK;
	VariantProperty<VariantProperties.Rotation> yRot = VariantProperties.Y_ROT;
	return MultiVariantGenerator.multiVariant(vertSlabBlock).with(PropertyDispatch.properties(VerticalSlabBlock.FACING, VerticalSlabBlock.SINGLE)
			.select(Direction.NORTH, true, Variant.variant().with(VariantProperties.MODEL, vertSlabId).with(uvlock, true))
			.select(Direction.EAST, true, Variant.variant().with(VariantProperties.MODEL, vertSlabId).with(uvlock, true).with(yRot, VariantProperties.Rotation.R90))
			.select(Direction.SOUTH, true, Variant.variant().with(VariantProperties.MODEL, vertSlabId).with(uvlock, true).with(yRot, VariantProperties.Rotation.R180))
			.select(Direction.WEST, true, Variant.variant().with(VariantProperties.MODEL, vertSlabId).with(uvlock, true).with(yRot, VariantProperties.Rotation.R270))
			.select(Direction.NORTH, false, Variant.variant().with(VariantProperties.MODEL, fullBlockId).with(uvlock, true))
			.select(Direction.EAST, false, Variant.variant().with(VariantProperties.MODEL, fullBlockId).with(uvlock, true))
			.select(Direction.SOUTH, false, Variant.variant().with(VariantProperties.MODEL, fullBlockId).with(uvlock, true))
			.select(Direction.WEST, false, Variant.variant().with(VariantProperties.MODEL, fullBlockId).with(uvlock, true)));
}

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

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.

public static void registerVerticalSlab(BlockModelGenerators generator, Block vertSlabBlock, Block fullBlock, TextureMapping textures) {
	ResourceLocation slabModel = VERTICAL_SLAB.create(vertSlabBlock, textures, generator.modelOutput);
	ResourceLocation fullBlockModel = ModelLocationUtils.getModelLocation(fullBlock);
	generator.blockStateOutput.accept(createVerticalSlabBlockStates(vertSlabBlock, slabModel, fullBlockModel));
	generator.registerSimpleItemModel(vertSlabBlock, slabModel);
}

Zunächst erhalten wir den ResourceLocation des einzelnen Stufenmodell mit VERTICAL_SLAB.upload(). Dann erhalten wir den ResourceLocation 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:

CustomBlockStateModelGenerator.registerVerticalSlab(
		blockStateModelGenerator,
		ModBlocks.VERTICAL_OAK_LOG_SLAB,
		Blocks.OAK_LOG,
		CustomBlockStateModelGenerator.blockAndTopForEnds(Blocks.OAK_LOG)
);

Quellen und Links

Du kannst für weitere Informationen die Beispieltests in der Fabric API und im Referenz-Mod 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 und Vanilla+ Verticals von Fellteros.