Make TransformType enum extensible, includes the possibility to specify a fallback type for cases where models don't specify the transform explicitly. (#8566)

Makes it possible to add new perspectives.
This commit is contained in:
gigaherz authored and GitHub committed 2022-05-22 17:55:48 +01:00
1 parent aded6fb847
commit 4c09d8d774
19 files changed
+593 -61

No files matched your search

@@ -92,7 +92,6 @@ import net.minecraftforge.client.model.generators.BlockStateProvider;
import net.minecraftforge.client.model.generators.ConfiguredModel;
import net.minecraftforge.client.model.generators.ItemModelProvider;
import net.minecraftforge.client.model.generators.ModelBuilder;
import net.minecraftforge.client.model.generators.ModelBuilder.Perspective;
import net.minecraftforge.client.model.generators.ModelFile;
import net.minecraftforge.client.model.generators.ModelFile.UncheckedModelFile;
import net.minecraftforge.client.model.generators.MultiPartBlockStateBuilder;
@@ -753,27 +752,27 @@ public class DataGeneratorTest
ModelFile block = models().getBuilder("block")
.guiLight(GuiLight.SIDE)
.transforms()
.transform(Perspective.GUI)
.transform(ItemTransforms.TransformType.GUI)
.rotation(30, 225, 0)
.scale(0.625f)
.end()
.transform(Perspective.GROUND)
.transform(ItemTransforms.TransformType.GROUND)
.translation(0, 3, 0)
.scale(0.25f)
.end()
.transform(Perspective.FIXED)
.transform(ItemTransforms.TransformType.FIXED)
.scale(0.5f)
.end()
.transform(Perspective.THIRDPERSON_RIGHT)
.transform(ItemTransforms.TransformType.THIRD_PERSON_RIGHT_HAND)
.rotation(75, 45, 0)
.translation(0, 2.5f, 0)
.scale(0.375f)
.end()
.transform(Perspective.FIRSTPERSON_RIGHT)
.transform(ItemTransforms.TransformType.FIRST_PERSON_RIGHT_HAND)
.rotation(0, 45, 0)
.scale(0.4f)
.end()
.transform(Perspective.FIRSTPERSON_LEFT)
.transform(ItemTransforms.TransformType.FIRST_PERSON_LEFT_HAND)
.rotation(0, 225, 0)
.scale(0.4f)
.end()
@@ -1111,8 +1110,8 @@ public class DataGeneratorTest
} else if (generatedDisplay != null) { // Both must be non-null
ItemTransforms generatedTransforms = GSON.fromJson(generatedDisplay, ItemTransforms.class);
ItemTransforms vanillaTransforms = GSON.fromJson(vanillaDisplay, ItemTransforms.class);
for (Perspective type : Perspective.values()) {
if (!generatedTransforms.getTransform(type.vanillaType).equals(vanillaTransforms.getTransform(type.vanillaType))) {
for (ItemTransforms.TransformType type : ItemTransforms.TransformType.values()) {
if (!generatedTransforms.getTransform(type).equals(vanillaTransforms.getTransform(type))) {
ret.add("Model " + loc + " has transforms that differ from vanilla equivalent for perspective " + type.name());
return;
}
@@ -0,0 +1,299 @@
/*
* Copyright (c) Forge Development LLC and contributors
* SPDX-License-Identifier: LGPL-2.1-only
*/
package net.minecraftforge.debug.client.model;
import com.mojang.blaze3d.vertex.PoseStack;
import net.minecraft.client.Minecraft;
import net.minecraft.client.renderer.MultiBufferSource;
import net.minecraft.client.renderer.block.model.ItemTransforms;
import net.minecraft.client.renderer.blockentity.BlockEntityRenderer;
import net.minecraft.client.renderer.blockentity.BlockEntityRendererProvider;
import net.minecraft.client.renderer.entity.ItemRenderer;
import net.minecraft.core.BlockPos;
import net.minecraft.core.Direction;
import net.minecraft.data.DataGenerator;
import net.minecraft.data.models.model.ModelLocationUtils;
import net.minecraft.nbt.CompoundTag;
import net.minecraft.network.Connection;
import net.minecraft.network.protocol.Packet;
import net.minecraft.network.protocol.game.ClientGamePacketListener;
import net.minecraft.network.protocol.game.ClientboundBlockEntityDataPacket;
import net.minecraft.resources.ResourceLocation;
import net.minecraft.world.InteractionHand;
import net.minecraft.world.entity.player.Player;
import net.minecraft.world.item.*;
import net.minecraft.world.item.context.BlockPlaceContext;
import net.minecraft.world.level.block.Block;
import net.minecraft.world.level.block.EntityBlock;
import net.minecraft.world.level.block.HorizontalDirectionalBlock;
import net.minecraft.world.level.block.RenderShape;
import net.minecraft.world.level.block.entity.BlockEntity;
import net.minecraft.world.level.block.entity.BlockEntityType;
import net.minecraft.world.level.block.state.BlockBehaviour;
import net.minecraft.world.level.block.state.BlockState;
import net.minecraft.world.level.block.state.StateDefinition;
import net.minecraft.world.level.material.Material;
import net.minecraftforge.api.distmarker.Dist;
import net.minecraftforge.client.event.EntityRenderersEvent;
import net.minecraftforge.client.model.generators.*;
import net.minecraftforge.common.data.ExistingFileHelper;
import net.minecraftforge.eventbus.api.SubscribeEvent;
import net.minecraftforge.fml.common.Mod;
import net.minecraftforge.fml.javafmlmod.FMLJavaModLoadingContext;
import net.minecraftforge.forge.event.lifecycle.GatherDataEvent;
import net.minecraftforge.registries.DeferredRegister;
import net.minecraftforge.registries.ForgeRegistries;
import net.minecraftforge.registries.RegistryObject;
import org.jetbrains.annotations.Nullable;
/*
* Test mod for the custom transform types feature.
* This test mod adds an item that should be held in the main hand, while another item is in the offhand.
* When right-clicked on a block, the item will "hang" the stack from the offhand slot on the wall.
* In addition, a replacement model for the stick is provided in the resources.
* If the feature is working, the stick will have a custom transform while hanging on walls,
* when compared to similar items such as a fishing rod.
* Editing that model json will reflect ingame after a resource reload (F3+T).
*/
@Mod(CustomTransformTypeTest.MODID)
public class CustomTransformTypeTest
{
public static final String MODID = "custom_transformtype_test";
@Mod.EventBusSubscriber(value= Dist.CLIENT, modid = MODID, bus= Mod.EventBusSubscriber.Bus.MOD)
private static class RendererEvents
{
public static final ItemTransforms.TransformType HANGING = ItemTransforms.TransformType.create(
"custom_transformtype_test_hanging",
new ResourceLocation("custom_transformtype_test", "hanging")
);
@SubscribeEvent
public static void registerRenderers(EntityRenderersEvent.RegisterRenderers event)
{
event.registerBlockEntityRenderer(ITEM_HANGER_BE.get(), ItemHangerBlockEntityRenderer::new);
}
private static class ItemHangerBlockEntityRenderer
implements BlockEntityRenderer<ItemHangerBlockEntity>
{
public ItemHangerBlockEntityRenderer(BlockEntityRendererProvider.Context context)
{
}
@Override
public void render(ItemHangerBlockEntity blocken, float partialTicks, PoseStack poseStack, MultiBufferSource bufferSource, int packedLight, int overlayCoord)
{
var state = blocken.getBlockState();
if (!(state.getBlock() instanceof ItemHangerBlock)) return;
poseStack.pushPose();
poseStack.translate(0.5,0.5,0.5);
poseStack.mulPose(state.getValue(ItemHangerBlock.FACING).getRotation());
poseStack.translate(-0.5,-0.5,-0.5);
ItemRenderer itemRenderer = Minecraft.getInstance().getItemRenderer();
var model = itemRenderer.getModel(blocken.heldItem, blocken.getLevel(), null, 0);
itemRenderer.render(blocken.heldItem, HANGING, false, poseStack, bufferSource, packedLight, overlayCoord, model);
poseStack.popPose();
}
}
}
public static final DeferredRegister<Item> ITEMS = DeferredRegister.create(ForgeRegistries.ITEMS, MODID);
public static final DeferredRegister<Block> BLOCKS = DeferredRegister.create(ForgeRegistries.BLOCKS, MODID);
public static final DeferredRegister<BlockEntityType<?>> BLOCK_ENTITY_TYPES = DeferredRegister.create(ForgeRegistries.BLOCK_ENTITIES, MODID);
public static final RegistryObject<Block>
ITEM_HANGER_BLOCK = BLOCKS.register("item_hanger", () -> new ItemHangerBlock(BlockBehaviour.Properties.of(Material.WOOL).noCollission().noOcclusion().noDrops()));
public static final RegistryObject<BlockEntityType<ItemHangerBlockEntity>>
ITEM_HANGER_BE = BLOCK_ENTITY_TYPES.register("item_hanger", () -> BlockEntityType.Builder.of(ItemHangerBlockEntity::new, ITEM_HANGER_BLOCK.get()).build(null));
public static final RegistryObject<Item>
ITEM_HANGER_ITEM = ITEMS.register("item_hanger", () -> new ItemHangerItem(ITEM_HANGER_BLOCK.get(), new Item.Properties().tab(CreativeModeTab.TAB_MISC)));
public CustomTransformTypeTest()
{
var modBus = FMLJavaModLoadingContext.get().getModEventBus();
modBus.addListener(this::gatherData);
BLOCKS.register(modBus);
BLOCK_ENTITY_TYPES.register(modBus);
ITEMS.register(modBus);
}
public void gatherData(GatherDataEvent event)
{
DataGenerator gen = event.getGenerator();
if (event.includeClient())
{
gen.addProvider(new ItemModels(gen, event.getExistingFileHelper()));
gen.addProvider(new BlockStateModels(gen, event.getExistingFileHelper()));
}
}
public static class BlockStateModels extends BlockStateProvider
{
public BlockStateModels(DataGenerator gen, ExistingFileHelper exFileHelper)
{
super(gen, MODID, exFileHelper);
}
@Override
protected void registerStatesAndModels()
{
{
Block block = ITEM_HANGER_BLOCK.get();
horizontalBlock(block, models().getExistingFile(ModelLocationUtils.getModelLocation(block)));
}
}
}
public static class ItemModels extends ItemModelProvider
{
public ItemModels(DataGenerator generator, ExistingFileHelper existingFileHelper)
{
super(generator, MODID, existingFileHelper);
}
@Override
protected void registerModels()
{
basicItem(ITEM_HANGER_ITEM.get());
basicItem(Items.STICK)
.transforms()
.transform(RendererEvents.HANGING)
.rotation(62, 180 - 33, 40)
.translation(-2.25f, 1.5f, -0.25f).scale(0.48f)
.end()
.end();
}
}
private static class ItemHangerBlock extends HorizontalDirectionalBlock implements EntityBlock
{
public ItemHangerBlock(BlockBehaviour.Properties properties)
{
super(properties);
registerDefaultState(getStateDefinition().any().setValue(FACING, Direction.NORTH));
}
@Override
protected void createBlockStateDefinition(StateDefinition.Builder<Block, BlockState> builder) {
builder.add(FACING);
}
@Nullable
@Override
public BlockState getStateForPlacement(BlockPlaceContext ctx)
{
return defaultBlockState().setValue(FACING, ctx.getHorizontalDirection());
}
@Nullable
@Override
public BlockEntity newBlockEntity(BlockPos pos, BlockState state)
{
return new ItemHangerBlockEntity(pos, state);
}
@Deprecated
@Override
public RenderShape getRenderShape(BlockState state)
{
return RenderShape.ENTITYBLOCK_ANIMATED;
}
}
private static class ItemHangerBlockEntity extends BlockEntity
{
private ItemStack heldItem;
public ItemHangerBlockEntity(BlockEntityType<?> type, BlockPos blockPos, BlockState blockState)
{
super(type, blockPos, blockState);
}
public ItemHangerBlockEntity(BlockPos blockPos, BlockState blockState)
{
this(ITEM_HANGER_BE.get(), blockPos, blockState);
}
@Override
public CompoundTag getUpdateTag()
{
return saveWithoutMetadata();
}
@Nullable
@Override
public Packet<ClientGamePacketListener> getUpdatePacket()
{
return ClientboundBlockEntityDataPacket.create(this, BlockEntity::getUpdateTag);
}
@Override
public void handleUpdateTag(CompoundTag tag)
{
load(tag);
}
@Override
public void onDataPacket(Connection net, ClientboundBlockEntityDataPacket pkt)
{
handleUpdateTag(pkt.getTag());
}
@Override
protected void saveAdditional(CompoundTag tag)
{
var c = new CompoundTag();
heldItem.save(c);
tag.put("item", c);
}
@Override
public void load(CompoundTag tag)
{
var c = tag.getCompound("item");
heldItem = ItemStack.of(c);
}
}
private static class ItemHangerItem extends BlockItem
{
public ItemHangerItem(Block block, Item.Properties properties)
{
super(block, properties);
}
@Override
protected boolean placeBlock(BlockPlaceContext ctx, BlockState state)
{
Player player = ctx.getPlayer();
if (player == null)
return false;
var hand = ctx.getHand();
if (hand != InteractionHand.MAIN_HAND)
{
return false;
}
if (!super.placeBlock(ctx, state))
return false;
if (ctx.getLevel().getBlockEntity(ctx.getClickedPos()) instanceof ItemHangerBlockEntity be)
{
be.heldItem = player.getItemInHand(InteractionHand.OFF_HAND);
}
return true;
}
}
}