From acaf7f6475ac64cb3986af38fea5418f31b5ac8e Mon Sep 17 00:00:00 2001 From: 90 Date: Wed, 4 Oct 2023 09:14:08 +0300 Subject: [PATCH] Move model datagen to common --- .../datagen/CommonModelProvider.java | 487 ++++++++++++++++++ .../datagen/CommonRecipeProvider.java | 3 +- .../mixin/data/TextureSlotAccessor.java | 14 + fabric/build.gradle.kts | 2 +- .../megacells/datagen/MEGADataGenerators.java | 2 +- .../_90/megacells/datagen/ModelProvider.java | 429 --------------- .../megacells/datagen/ForgeModelProvider.java | 54 ++ .../megacells/datagen/MEGADataGenerators.java | 7 +- .../_90/megacells/datagen/ModelProvider.java | 331 ------------ .../mixin/data/{ => forge}/MainMixin.java | 2 +- .../data/resources/megacells.data.mixins.json | 2 +- 11 files changed, 563 insertions(+), 770 deletions(-) create mode 100644 common/src/data/java/gripe/_90/megacells/datagen/CommonModelProvider.java create mode 100644 common/src/data/java/gripe/_90/megacells/mixin/data/TextureSlotAccessor.java delete mode 100644 fabric/src/data/java/gripe/_90/megacells/datagen/ModelProvider.java create mode 100644 forge/src/data/java/gripe/_90/megacells/datagen/ForgeModelProvider.java delete mode 100644 forge/src/data/java/gripe/_90/megacells/datagen/ModelProvider.java rename forge/src/data/java/gripe/_90/megacells/mixin/data/{ => forge}/MainMixin.java (92%) diff --git a/common/src/data/java/gripe/_90/megacells/datagen/CommonModelProvider.java b/common/src/data/java/gripe/_90/megacells/datagen/CommonModelProvider.java new file mode 100644 index 00000000..9afbda45 --- /dev/null +++ b/common/src/data/java/gripe/_90/megacells/datagen/CommonModelProvider.java @@ -0,0 +1,487 @@ +package gripe._90.megacells.datagen; + +import java.nio.file.Path; +import java.util.HashMap; +import java.util.Map; +import java.util.Optional; +import java.util.concurrent.CompletableFuture; +import java.util.function.BiConsumer; +import java.util.function.Consumer; +import java.util.function.Function; +import java.util.function.Supplier; + +import com.google.gson.JsonArray; +import com.google.gson.JsonElement; +import com.google.gson.JsonObject; +import com.google.gson.JsonPrimitive; + +import org.jetbrains.annotations.NotNull; + +import net.minecraft.core.registries.BuiltInRegistries; +import net.minecraft.data.CachedOutput; +import net.minecraft.data.DataProvider; +import net.minecraft.data.PackOutput; +import net.minecraft.data.models.BlockModelGenerators; +import net.minecraft.data.models.blockstates.BlockStateGenerator; +import net.minecraft.data.models.blockstates.MultiVariantGenerator; +import net.minecraft.data.models.blockstates.PropertyDispatch; +import net.minecraft.data.models.blockstates.Variant; +import net.minecraft.data.models.blockstates.VariantProperties; +import net.minecraft.data.models.blockstates.VariantProperty; +import net.minecraft.data.models.model.DelegatedModel; +import net.minecraft.data.models.model.ModelLocationUtils; +import net.minecraft.data.models.model.ModelTemplate; +import net.minecraft.data.models.model.ModelTemplates; +import net.minecraft.data.models.model.TextureMapping; +import net.minecraft.data.models.model.TextureSlot; +import net.minecraft.data.models.model.TexturedModel; +import net.minecraft.resources.ResourceLocation; +import net.minecraft.world.item.Item; +import net.minecraft.world.level.block.Block; +import net.minecraft.world.level.block.state.properties.BlockStateProperties; + +import appeng.api.orientation.BlockOrientation; +import appeng.block.crafting.AbstractCraftingUnitBlock; +import appeng.block.crafting.PatternProviderBlock; +import appeng.block.networking.EnergyCellBlock; +import appeng.core.AppEng; +import appeng.core.definitions.AEItems; +import appeng.core.definitions.BlockDefinition; +import appeng.core.definitions.ItemDefinition; + +import gripe._90.megacells.MEGACells; +import gripe._90.megacells.core.Addons; +import gripe._90.megacells.core.Loaders; +import gripe._90.megacells.definition.MEGABlocks; +import gripe._90.megacells.definition.MEGAItems; +import gripe._90.megacells.integration.appbot.AppBotItems; +import gripe._90.megacells.mixin.data.TextureSlotAccessor; + +public class CommonModelProvider implements DataProvider { + private static final TextureSlot LAYER3 = textureSlot("layer3"); + private static final ModelTemplate PORTABLE = new ModelTemplate( + Optional.of(new ResourceLocation("minecraft:item/generated")), + Optional.empty(), + TextureSlot.LAYER0, + TextureSlot.LAYER1, + TextureSlot.LAYER2, + LAYER3); + + private static final TextureSlot CELL = textureSlot("cell"); + private static final ModelTemplate DRIVE_CELL = + new ModelTemplate(Optional.of(AppEng.makeId("block/drive/drive_cell")), Optional.empty(), CELL); + + private static final TextureSlot SIDES = textureSlot("sides"); + private static final TextureSlot SIDES_STATUS = textureSlot("sidesStatus"); + private static final ModelTemplate INTERFACE = new ModelTemplate( + Optional.of(AppEng.makeId("part/interface_base")), + Optional.empty(), + SIDES, + SIDES_STATUS, + TextureSlot.BACK, + TextureSlot.FRONT, + TextureSlot.PARTICLE); + private static final ModelTemplate CABLE_INTERFACE = new ModelTemplate( + Optional.of(AppEng.makeId("item/cable_interface")), + Optional.empty(), + SIDES, + TextureSlot.BACK, + TextureSlot.FRONT); + + private static final VariantProperty Z_ROT = + new VariantProperty<>("ae2:z", r -> new JsonPrimitive(r.ordinal() * 90)); + + private final PackOutput output; + + public CommonModelProvider(PackOutput output) { + this.output = output; + } + + private static TextureSlot textureSlot(String key) { + return MEGACells.PLATFORM.getLoader() == Loaders.FABRIC + ? TextureSlot.create(key) + : TextureSlotAccessor.invokeCreate(key); + } + + @NotNull + @Override + public CompletableFuture run(CachedOutput writer) { + var states = new HashMap(); + var models = new HashMap>(); + + generateBlockStateModels(gen -> states.put(gen.getBlock(), gen), models::put); + generateItemModels(models::put); + + var blockStatePathProvider = output.createPathProvider(PackOutput.Target.RESOURCE_PACK, "blockstates"); + var modelPathProvider = output.createPathProvider(PackOutput.Target.RESOURCE_PACK, "models"); + + return CompletableFuture.allOf( + saveCollection(writer, states, b -> blockStatePathProvider.json(BuiltInRegistries.BLOCK.getKey(b))), + saveCollection(writer, models, modelPathProvider::json)); + } + + private CompletableFuture saveCollection( + CachedOutput writer, Map> map, Function function) { + return CompletableFuture.allOf(map.keySet().stream() + .map(key -> DataProvider.saveStable(writer, map.get(key).get(), function.apply(key))) + .toArray(CompletableFuture[]::new)); + } + + private void generateBlockStateModels( + Consumer blockStateOutput, + BiConsumer> modelOutput) { + simpleBlock(MEGABlocks.SKY_STEEL_BLOCK, blockStateOutput, modelOutput); + simpleBlock(MEGABlocks.MEGA_INTERFACE, blockStateOutput, modelOutput); + + craftingUnit(MEGABlocks.MEGA_CRAFTING_UNIT, "unit", blockStateOutput, modelOutput); + craftingUnit(MEGABlocks.CRAFTING_STORAGE_1M, "1m_storage", blockStateOutput, modelOutput); + craftingUnit(MEGABlocks.CRAFTING_STORAGE_4M, "4m_storage", blockStateOutput, modelOutput); + craftingUnit(MEGABlocks.CRAFTING_STORAGE_16M, "16m_storage", blockStateOutput, modelOutput); + craftingUnit(MEGABlocks.CRAFTING_STORAGE_64M, "64m_storage", blockStateOutput, modelOutput); + craftingUnit(MEGABlocks.CRAFTING_STORAGE_256M, "256m_storage", blockStateOutput, modelOutput); + craftingUnit(MEGABlocks.CRAFTING_ACCELERATOR, "accelerator", blockStateOutput, modelOutput); + + energyCell(blockStateOutput, modelOutput); + patternProviderBlock(blockStateOutput, modelOutput); + craftingMonitor(blockStateOutput, modelOutput); + } + + private void generateItemModels(BiConsumer> output) { + flatItem(MEGAItems.SKY_STEEL_INGOT, output); + + flatItem(MEGAItems.ACCUMULATION_PROCESSOR_PRESS, output); + flatItem(MEGAItems.ACCUMULATION_PROCESSOR_PRINT, output); + flatItem(MEGAItems.ACCUMULATION_PROCESSOR, output); + + flatItem(MEGAItems.MEGA_ITEM_CELL_HOUSING, output); + flatItem(MEGAItems.MEGA_FLUID_CELL_HOUSING, output); + + flatItem(MEGAItems.CELL_COMPONENT_1M, output); + flatItem(MEGAItems.CELL_COMPONENT_4M, output); + flatItem(MEGAItems.CELL_COMPONENT_16M, output); + flatItem(MEGAItems.CELL_COMPONENT_64M, output); + flatItem(MEGAItems.CELL_COMPONENT_256M, output); + flatItem(MEGAItems.BULK_CELL_COMPONENT, output); + + flatItem(MEGAItems.GREATER_ENERGY_CARD, output); + flatItem(MEGAItems.COMPRESSION_CARD, output); + + ModelTemplates.FLAT_ITEM.create( + ModelLocationUtils.getModelLocation(MEGAItems.DECOMPRESSION_PATTERN.asItem()), + TextureMapping.layer0(AEItems.CRAFTING_PATTERN.asItem()), + output); + + MEGAItems.getItemCells().forEach(cell -> cellModel(cell, output)); + MEGAItems.getFluidCells().forEach(cell -> cellModel(cell, output)); + cellModel(MEGAItems.BULK_ITEM_CELL, output); + + for (var portable : MEGAItems.getItemPortables()) { + portableModel(portable, "item", AppEng.makeId("item/portable_cell_item_housing"), output); + } + + for (var portable : MEGAItems.getFluidPortables()) { + portableModel(portable, "fluid", AppEng.makeId("item/portable_cell_fluid_housing"), output); + } + + driveCell("mega_item_cell", output); + driveCell("mega_fluid_cell", output); + driveCell("bulk_item_cell", output); + + if (MEGACells.PLATFORM.isAddonLoaded(Addons.APPBOT)) { + flatItem(AppBotItems.MEGA_MANA_CELL_HOUSING, output); + AppBotItems.getCells().forEach(cell -> cellModel(cell, output)); + + // TODO: portables + driveCell("mega_mana_cell", output); + } + + interfaceOrProviderPart(MEGAItems.MEGA_INTERFACE, output); + interfaceOrProviderPart(MEGAItems.MEGA_PATTERN_PROVIDER, output); + } + + private void flatItem(ItemDefinition item, BiConsumer> output) { + ModelTemplates.FLAT_ITEM.create( + ModelLocationUtils.getModelLocation(item.asItem()), TextureMapping.layer0(item.asItem()), output); + } + + private void cellModel(ItemDefinition cell, BiConsumer> output) { + ModelTemplates.TWO_LAYERED_ITEM.create( + ModelLocationUtils.getModelLocation(cell.asItem()), + TextureMapping.layered( + MEGACells.makeId("item/cell/standard/" + cell.id().getPath()), + AppEng.makeId("item/storage_cell_led")), + output); + } + + private void portableModel( + ItemDefinition portable, + String screenType, + ResourceLocation housingTexture, + BiConsumer> output) { + var path = portable.id().getPath(); + var tierSuffix = path.substring(path.lastIndexOf('_') + 1); + PORTABLE.create( + MEGACells.makeId("item/" + portable.id().getPath()), + new TextureMapping() + .put( + TextureSlot.LAYER0, + MEGACells.makeId("item/cell/portable/portable_cell_" + screenType + "_screen")) + .put(TextureSlot.LAYER1, AppEng.makeId("item/portable_cell_led")) + .put(TextureSlot.LAYER2, housingTexture) + .put(LAYER3, MEGACells.makeId("item/cell/portable/portable_cell_side_" + tierSuffix)), + output); + } + + private void driveCell(String texture, BiConsumer> output) { + var path = MEGACells.makeId("block/drive/cells/" + texture); + DRIVE_CELL.create(path, new TextureMapping().put(CELL, path), output); + } + + private void interfaceOrProviderPart( + ItemDefinition part, BiConsumer> output) { + var partName = part.id().getPath().substring(6); + var front = MEGACells.makeId("part/" + partName); + var back = MEGACells.makeId("part/" + partName + "_back"); + var sides = MEGACells.makeId("part/" + partName + "_sides"); + INTERFACE.create( + MEGACells.makeId("part/" + partName), + new TextureMapping() + .put(SIDES_STATUS, MEGACells.makeId("part/mega_monitor_sides_status")) + .put(SIDES, sides) + .put(TextureSlot.BACK, back) + .put(TextureSlot.FRONT, front) + .put(TextureSlot.PARTICLE, back), + output); + CABLE_INTERFACE.create( + MEGACells.makeId("item/" + part.id().getPath()), + new TextureMapping() + .put(SIDES, sides) + .put(TextureSlot.FRONT, front) + .put(TextureSlot.BACK, back), + output); + } + + private void simpleBlock( + BlockDefinition block, + Consumer blockStateOutput, + BiConsumer> modelOutput) { + blockStateOutput.accept(BlockModelGenerators.createSimpleBlock( + block.block(), TexturedModel.CUBE.create(block.block(), modelOutput))); + modelOutput.accept( + ModelLocationUtils.getModelLocation(Item.BY_BLOCK.get(block.block())), + new DelegatedModel(ModelLocationUtils.getModelLocation(block.block()))); + } + + private void energyCell( + Consumer blockStateOutput, + BiConsumer> modelOutput) { + var cell = MEGABlocks.MEGA_ENERGY_CELL; + var fillStage = PropertyDispatch.property(EnergyCellBlock.ENERGY_STORAGE); + var overrides = new HashMap(); + + for (var i = 0; i < 5; i++) { + var suffix = "_" + i; + var model = ModelTemplates.CUBE_ALL.createWithSuffix( + cell.block(), + suffix, + TextureMapping.cube(TextureMapping.getBlockTexture(cell.block(), suffix)), + modelOutput); + + fillStage.select(i, Variant.variant().with(VariantProperties.MODEL, model)); + + if (i < 4) { + var fillPredicate = new JsonObject(); + fillPredicate.addProperty("ae2:fill_level", 0.25 * i); + overrides.put(MEGACells.makeId("block/" + cell.id().getPath() + "_" + (i + 1)), fillPredicate); + } + } + + blockStateOutput.accept(MultiVariantGenerator.multiVariant(cell.block()).with(fillStage)); + modelOutput.accept( + ModelLocationUtils.getModelLocation(cell.asItem()), + new OverrideableDelegatedModel( + MEGACells.makeId("block/" + cell.id().getPath() + "_0"), overrides)); + } + + private void craftingUnit( + BlockDefinition unit, + String texture, + Consumer blockStateOutput, + BiConsumer> modelOutput) { + var formed = MEGACells.makeId("block/crafting/" + texture + "_formed"); + var unformed = MEGACells.makeId("block/crafting/" + texture); + + var craftingUnit = MultiVariantGenerator.multiVariant(unit.block()) + .with(PropertyDispatch.property(AbstractCraftingUnitBlock.FORMED) + .select( + false, + Variant.variant() + .with( + VariantProperties.MODEL, + ModelTemplates.CUBE_ALL.create( + unformed, TextureMapping.cube(unformed), modelOutput))) + .select(true, Variant.variant().with(VariantProperties.MODEL, formed))); + + blockStateOutput.accept(craftingUnit); + modelOutput.accept(formed, () -> customModelLoader(formed)); + modelOutput.accept(ModelLocationUtils.getModelLocation(unit.asItem()), new DelegatedModel(unformed)); + } + + private void craftingMonitor( + Consumer blockStateOutput, + BiConsumer> modelOutput) { + var unformed = MEGACells.makeId("block/crafting/monitor"); + var unit = MEGACells.makeId("block/crafting/unit"); + var unformedModel = ModelTemplates.CUBE.create( + unformed, + new TextureMapping() + .put(TextureSlot.NORTH, unformed) + .put(TextureSlot.EAST, unit) + .put(TextureSlot.SOUTH, unit) + .put(TextureSlot.WEST, unit) + .put(TextureSlot.DOWN, unit) + .put(TextureSlot.UP, unit) + .put(TextureSlot.PARTICLE, unformed), + modelOutput); + + var formedModel = MEGACells.makeId("block/crafting/monitor_formed"); + blockStateOutput.accept(MultiVariantGenerator.multiVariant(MEGABlocks.CRAFTING_MONITOR.block()) + .with(PropertyDispatch.properties(AbstractCraftingUnitBlock.FORMED, BlockStateProperties.FACING) + .generate((formed, facing) -> { + if (formed) { + return Variant.variant().with(VariantProperties.MODEL, formedModel); + } else { + return applyOrientation( + Variant.variant().with(VariantProperties.MODEL, unformedModel), + BlockOrientation.get(facing)); + } + }))); + modelOutput.accept(formedModel, () -> customModelLoader(formedModel)); + modelOutput.accept( + ModelLocationUtils.getModelLocation(MEGABlocks.CRAFTING_MONITOR.asItem()), + new DelegatedModel(unformed)); + } + + private void patternProviderBlock( + Consumer blockStateOutput, + BiConsumer> modelOutput) { + var normal = ModelTemplates.CUBE_ALL.create( + MEGABlocks.MEGA_PATTERN_PROVIDER.block(), + TextureMapping.cube(MEGABlocks.MEGA_PATTERN_PROVIDER.block()), + modelOutput); + var oriented = ModelTemplates.CUBE.create( + MEGACells.makeId("block/mega_pattern_provider_oriented"), + new TextureMapping() + .put(TextureSlot.UP, MEGACells.makeId("block/mega_pattern_provider_alternate_front")) + .put(TextureSlot.DOWN, MEGACells.makeId("block/mega_pattern_provider_alternate")) + .put(TextureSlot.NORTH, MEGACells.makeId("block/mega_pattern_provider_alternate_arrow")) + .copySlot(TextureSlot.NORTH, TextureSlot.EAST) + .copySlot(TextureSlot.NORTH, TextureSlot.SOUTH) + .copySlot(TextureSlot.NORTH, TextureSlot.WEST) + .put(TextureSlot.PARTICLE, normal), + modelOutput); + + blockStateOutput.accept(MultiVariantGenerator.multiVariant(MEGABlocks.MEGA_PATTERN_PROVIDER.block()) + .with(PropertyDispatch.property(PatternProviderBlock.PUSH_DIRECTION) + .generate(pushDirection -> { + var forward = pushDirection.getDirection(); + + if (forward == null) { + return Variant.variant().with(VariantProperties.MODEL, normal); + } else { + var orientation = BlockOrientation.get(forward); + return applyRotation( + Variant.variant().with(VariantProperties.MODEL, oriented), + // + 90 because the default model is oriented UP, while block orientation + // assumes NORTH + orientation.getAngleX() + 90, + orientation.getAngleY(), + 0); + } + }))); + + modelOutput.accept( + ModelLocationUtils.getModelLocation(MEGABlocks.MEGA_PATTERN_PROVIDER.asItem()), + new DelegatedModel(normal)); + } + + private Variant applyOrientation(Variant variant, BlockOrientation orientation) { + return applyRotation(variant, orientation.getAngleX(), orientation.getAngleY(), orientation.getAngleZ()); + } + + private Variant applyRotation(Variant variant, int angleX, int angleY, int angleZ) { + angleX = normalizeAngle(angleX); + angleY = normalizeAngle(angleY); + angleZ = normalizeAngle(angleZ); + + if (angleX != 0) { + variant = variant.with(VariantProperties.X_ROT, rotationByAngle(angleX)); + } + + if (angleY != 0) { + variant = variant.with(VariantProperties.Y_ROT, rotationByAngle(angleY)); + } + + if (angleZ != 0) { + variant = variant.with(Z_ROT, rotationByAngle(angleZ)); + } + + return variant; + } + + private int normalizeAngle(int angle) { + return angle - (angle / 360) * 360; + } + + private VariantProperties.Rotation rotationByAngle(int angle) { + return switch (angle) { + case 0 -> VariantProperties.Rotation.R0; + case 90 -> VariantProperties.Rotation.R90; + case 180 -> VariantProperties.Rotation.R180; + case 270 -> VariantProperties.Rotation.R270; + default -> throw new IllegalArgumentException("Invalid angle: " + angle); + }; + } + + private JsonObject customModelLoader(ResourceLocation loc) { + var json = new JsonObject(); + + if (MEGACells.PLATFORM.getLoader() == Loaders.FABRIC) { + json.addProperty("loader", loc.toString()); + } + + return json; + } + + @NotNull + @Override + public String getName() { + return "Common Models"; + } + + private static class OverrideableDelegatedModel extends DelegatedModel { + private final Map overrides; + + public OverrideableDelegatedModel(ResourceLocation id, Map overrides) { + super(id); + this.overrides = overrides; + } + + @NotNull + @Override + public JsonElement get() { + var json = super.get().getAsJsonObject(); + var array = new JsonArray(); + + for (var override : overrides.entrySet()) { + var entry = new JsonObject(); + entry.addProperty("model", override.getKey().toString()); + entry.add("predicate", override.getValue()); + array.add(entry); + } + + json.add("overrides", array); + return json; + } + } +} diff --git a/common/src/data/java/gripe/_90/megacells/datagen/CommonRecipeProvider.java b/common/src/data/java/gripe/_90/megacells/datagen/CommonRecipeProvider.java index acdfb3ce..05d023c7 100644 --- a/common/src/data/java/gripe/_90/megacells/datagen/CommonRecipeProvider.java +++ b/common/src/data/java/gripe/_90/megacells/datagen/CommonRecipeProvider.java @@ -2,6 +2,8 @@ import java.util.function.Consumer; +import org.jetbrains.annotations.NotNull; + import net.minecraft.core.registries.BuiltInRegistries; import net.minecraft.data.PackOutput; import net.minecraft.data.recipes.FinishedRecipe; @@ -35,7 +37,6 @@ import gripe._90.megacells.definition.MEGAItems; import gripe._90.megacells.definition.MEGATags; import gripe._90.megacells.integration.appbot.AppBotItems; -import org.jetbrains.annotations.NotNull; public class CommonRecipeProvider extends RecipeProvider { public CommonRecipeProvider(PackOutput output) { diff --git a/common/src/data/java/gripe/_90/megacells/mixin/data/TextureSlotAccessor.java b/common/src/data/java/gripe/_90/megacells/mixin/data/TextureSlotAccessor.java new file mode 100644 index 00000000..de9731f8 --- /dev/null +++ b/common/src/data/java/gripe/_90/megacells/mixin/data/TextureSlotAccessor.java @@ -0,0 +1,14 @@ +package gripe._90.megacells.mixin.data; + +import org.spongepowered.asm.mixin.Mixin; +import org.spongepowered.asm.mixin.gen.Invoker; + +import net.minecraft.data.models.model.TextureSlot; + +@Mixin(TextureSlot.class) +public interface TextureSlotAccessor { + @Invoker + static TextureSlot invokeCreate(String string) { + throw new AssertionError(); + } +} diff --git a/fabric/build.gradle.kts b/fabric/build.gradle.kts index 24a1a491..2643f947 100644 --- a/fabric/build.gradle.kts +++ b/fabric/build.gradle.kts @@ -8,7 +8,7 @@ loom { property("fabric-api.datagen") property("fabric-api.datagen.modid", rootProject.property("modId").toString()) property("fabric-api.datagen.output-dir", file("src/generated/resources").absolutePath) - property("fabric-api.datagen.strict-validation") + // property("fabric-api.datagen.strict-validation") } } } diff --git a/fabric/src/data/java/gripe/_90/megacells/datagen/MEGADataGenerators.java b/fabric/src/data/java/gripe/_90/megacells/datagen/MEGADataGenerators.java index 4d3e6c62..f3158306 100644 --- a/fabric/src/data/java/gripe/_90/megacells/datagen/MEGADataGenerators.java +++ b/fabric/src/data/java/gripe/_90/megacells/datagen/MEGADataGenerators.java @@ -15,6 +15,6 @@ public void onInitializeDataGenerator(FabricDataGenerator generator) { pack.addProvider((FabricDataOutput output) -> new CommonLanguageProvider(output)); pack.addProvider((FabricDataOutput output) -> new CommonLootTableProvider(output)); pack.addProvider((FabricDataOutput output) -> new CommonRecipeProvider(output)); - pack.addProvider(ModelProvider::new); + pack.addProvider((FabricDataOutput output) -> new CommonModelProvider(output)); } } diff --git a/fabric/src/data/java/gripe/_90/megacells/datagen/ModelProvider.java b/fabric/src/data/java/gripe/_90/megacells/datagen/ModelProvider.java deleted file mode 100644 index 3f29f9b1..00000000 --- a/fabric/src/data/java/gripe/_90/megacells/datagen/ModelProvider.java +++ /dev/null @@ -1,429 +0,0 @@ -package gripe._90.megacells.datagen; - -import java.util.ArrayList; -import java.util.List; -import java.util.Optional; - -import com.google.gson.JsonArray; -import com.google.gson.JsonElement; -import com.google.gson.JsonObject; -import com.google.gson.JsonPrimitive; -import com.ibm.icu.impl.Pair; - -import org.jetbrains.annotations.NotNull; - -import net.fabricmc.fabric.api.datagen.v1.FabricDataOutput; -import net.fabricmc.fabric.api.datagen.v1.provider.FabricModelProvider; -import net.minecraft.data.models.BlockModelGenerators; -import net.minecraft.data.models.ItemModelGenerators; -import net.minecraft.data.models.blockstates.MultiVariantGenerator; -import net.minecraft.data.models.blockstates.PropertyDispatch; -import net.minecraft.data.models.blockstates.Variant; -import net.minecraft.data.models.blockstates.VariantProperties; -import net.minecraft.data.models.blockstates.VariantProperty; -import net.minecraft.data.models.model.DelegatedModel; -import net.minecraft.data.models.model.ModelTemplate; -import net.minecraft.data.models.model.ModelTemplates; -import net.minecraft.data.models.model.TextureMapping; -import net.minecraft.data.models.model.TextureSlot; -import net.minecraft.resources.ResourceLocation; -import net.minecraft.world.level.block.Block; -import net.minecraft.world.level.block.state.properties.BlockStateProperties; - -import appeng.api.orientation.BlockOrientation; -import appeng.block.crafting.AbstractCraftingUnitBlock; -import appeng.block.crafting.PatternProviderBlock; -import appeng.block.networking.EnergyCellBlock; -import appeng.core.AppEng; -import appeng.core.definitions.AEItems; -import appeng.core.definitions.ItemDefinition; - -import gripe._90.megacells.MEGACells; -import gripe._90.megacells.core.Addons; -import gripe._90.megacells.definition.MEGABlocks; -import gripe._90.megacells.definition.MEGAItems; -import gripe._90.megacells.integration.appbot.AppBotItems; - -class ModelProvider extends FabricModelProvider { - private static final TextureSlot LAYER3 = TextureSlot.create("layer3"); - private static final ResourceLocation GENERATED = new ResourceLocation("item/generated"); - - private static final ModelTemplate CELL = - new ModelTemplate(Optional.of(GENERATED), Optional.empty(), TextureSlot.LAYER0, TextureSlot.LAYER1); - private static final ModelTemplate PORTABLE = new ModelTemplate( - Optional.of(GENERATED), - Optional.empty(), - TextureSlot.LAYER0, - TextureSlot.LAYER1, - TextureSlot.LAYER2, - LAYER3); - - private static final TextureSlot CELL_TEXTURE = TextureSlot.create("cell"); - private static final ModelTemplate DRIVE_CELL = - new ModelTemplate(Optional.of(AppEng.makeId("block/drive/drive_cell")), Optional.empty(), CELL_TEXTURE); - - private static final TextureSlot SIDES = TextureSlot.create("sides"); - private static final TextureSlot SIDES_STATUS = TextureSlot.create("sidesStatus"); - - private static final ModelTemplate INTERFACE = new ModelTemplate( - Optional.of(AppEng.makeId("part/interface_base")), - Optional.empty(), - SIDES, - SIDES_STATUS, - TextureSlot.BACK, - TextureSlot.FRONT, - TextureSlot.PARTICLE); - - private static final ModelTemplate CABLE_INTERFACE = new ModelTemplate( - Optional.of(AppEng.makeId("item/cable_interface")), - Optional.empty(), - SIDES, - TextureSlot.BACK, - TextureSlot.FRONT); - - private static final VariantProperty Z_ROT = - new VariantProperty<>("ae2:z", r -> new JsonPrimitive(r.ordinal() * 90)); - - ModelProvider(FabricDataOutput output) { - super(output); - } - - @Override - public void generateBlockStateModels(BlockModelGenerators generator) { - generator.createTrivialCube(MEGABlocks.SKY_STEEL_BLOCK.block()); - generator.createTrivialCube(MEGABlocks.MEGA_INTERFACE.block()); - - energyCell(generator); - - var craftingUnits = List.of( - Pair.of(MEGABlocks.MEGA_CRAFTING_UNIT, "unit"), - Pair.of(MEGABlocks.CRAFTING_STORAGE_1M, "1m_storage"), - Pair.of(MEGABlocks.CRAFTING_STORAGE_4M, "4m_storage"), - Pair.of(MEGABlocks.CRAFTING_STORAGE_16M, "16m_storage"), - Pair.of(MEGABlocks.CRAFTING_STORAGE_64M, "64m_storage"), - Pair.of(MEGABlocks.CRAFTING_STORAGE_256M, "256m_storage"), - Pair.of(MEGABlocks.CRAFTING_ACCELERATOR, "accelerator")); - - for (var block : craftingUnits) { - craftingUnit(block.first.block(), block.second, generator); - } - - craftingMonitor(generator); - patternProviderBlock(generator); - } - - @Override - public void generateItemModels(ItemModelGenerators generator) { - generator.generateFlatItem(MEGAItems.SKY_STEEL_INGOT.asItem(), ModelTemplates.FLAT_ITEM); - - generator.generateFlatItem(MEGAItems.ACCUMULATION_PROCESSOR_PRESS.asItem(), ModelTemplates.FLAT_ITEM); - generator.generateFlatItem(MEGAItems.ACCUMULATION_PROCESSOR_PRINT.asItem(), ModelTemplates.FLAT_ITEM); - generator.generateFlatItem(MEGAItems.ACCUMULATION_PROCESSOR.asItem(), ModelTemplates.FLAT_ITEM); - - generator.generateFlatItem(MEGAItems.MEGA_ITEM_CELL_HOUSING.asItem(), ModelTemplates.FLAT_ITEM); - generator.generateFlatItem(MEGAItems.MEGA_FLUID_CELL_HOUSING.asItem(), ModelTemplates.FLAT_ITEM); - - generator.generateFlatItem(MEGAItems.CELL_COMPONENT_1M.asItem(), ModelTemplates.FLAT_ITEM); - generator.generateFlatItem(MEGAItems.CELL_COMPONENT_4M.asItem(), ModelTemplates.FLAT_ITEM); - generator.generateFlatItem(MEGAItems.CELL_COMPONENT_16M.asItem(), ModelTemplates.FLAT_ITEM); - generator.generateFlatItem(MEGAItems.CELL_COMPONENT_64M.asItem(), ModelTemplates.FLAT_ITEM); - generator.generateFlatItem(MEGAItems.CELL_COMPONENT_256M.asItem(), ModelTemplates.FLAT_ITEM); - generator.generateFlatItem(MEGAItems.BULK_CELL_COMPONENT.asItem(), ModelTemplates.FLAT_ITEM); - - generator.generateFlatItem(MEGAItems.GREATER_ENERGY_CARD.asItem(), ModelTemplates.FLAT_ITEM); - generator.generateFlatItem(MEGAItems.COMPRESSION_CARD.asItem(), ModelTemplates.FLAT_ITEM); - - generator.generateFlatItem( - MEGAItems.DECOMPRESSION_PATTERN.asItem(), AEItems.CRAFTING_PATTERN.asItem(), ModelTemplates.FLAT_ITEM); - - var cells = new ArrayList<>(MEGAItems.getItemCells()); - cells.addAll(MEGAItems.getFluidCells()); - cells.add(MEGAItems.BULK_ITEM_CELL); - - if (MEGACells.PLATFORM.isAddonLoaded(Addons.APPBOT)) { - cells.addAll(AppBotItems.getCells()); - generator.generateFlatItem(AppBotItems.MEGA_MANA_CELL_HOUSING.asItem(), ModelTemplates.FLAT_ITEM); - - // lot of assumptions being made here in advance - AppBotItems.getPortables() - .forEach(p -> portableModel( - p, - "mana", - new ResourceLocation(Addons.APPBOT.getModId(), "item/portable_cell_mana_housing"), - generator)); - - driveCell("mega_mana_cell", generator); - } - - for (var cell : cells) { - cellModel(cell, generator); - } - - for (var portable : MEGAItems.getItemPortables()) { - portableModel(portable, "item", AppEng.makeId("item/portable_cell_item_housing"), generator); - } - - for (var portable : MEGAItems.getFluidPortables()) { - portableModel(portable, "fluid", AppEng.makeId("item/portable_cell_fluid_housing"), generator); - } - - driveCell("mega_item_cell", generator); - driveCell("mega_fluid_cell", generator); - driveCell("bulk_item_cell", generator); - - generatePartModels(generator); - } - - private void generatePartModels(ItemModelGenerators generator) { - interfaceOrProviderPart(generator, MEGAItems.MEGA_INTERFACE); - interfaceOrProviderPart(generator, MEGAItems.MEGA_PATTERN_PROVIDER); - } - - private void cellModel(ItemDefinition cell, ItemModelGenerators generator) { - CELL.create( - MEGACells.makeId("item/" + cell.id().getPath()), - new TextureMapping() - .put( - TextureSlot.LAYER0, - MEGACells.makeId( - "item/cell/standard/" + cell.id().getPath())) - .put(TextureSlot.LAYER1, AppEng.makeId("item/storage_cell_led")), - generator.output); - } - - private void portableModel( - ItemDefinition portable, - String screenType, - ResourceLocation housingTexture, - ItemModelGenerators generator) { - var path = portable.id().getPath(); - var tierSuffix = path.substring(path.lastIndexOf('_') + 1); - PORTABLE.create( - MEGACells.makeId("item/" + portable.id().getPath()), - new TextureMapping() - .put( - TextureSlot.LAYER0, - MEGACells.makeId("item/cell/portable/portable_cell_" + screenType + "_screen")) - .put(TextureSlot.LAYER1, AppEng.makeId("item/portable_cell_led")) - .put(TextureSlot.LAYER2, housingTexture) - .put(LAYER3, MEGACells.makeId("item/cell/portable/portable_cell_side_" + tierSuffix)), - generator.output); - } - - private void driveCell(String texture, ItemModelGenerators generator) { - var path = MEGACells.makeId("block/drive/cells/" + texture); - DRIVE_CELL.create(path, new TextureMapping().put(CELL_TEXTURE, path), generator.output); - } - - private void craftingUnit(Block block, String texture, BlockModelGenerators generator) { - var formed = MEGACells.makeId("block/crafting/" + texture + "_formed"); - var unformed = MEGACells.makeId("block/crafting/" + texture); - - var craftingUnit = MultiVariantGenerator.multiVariant(block) - .with(PropertyDispatch.property(AbstractCraftingUnitBlock.FORMED) - .select( - false, - Variant.variant() - .with( - VariantProperties.MODEL, - ModelTemplates.CUBE_ALL.create( - unformed, - TextureMapping.cube(unformed), - generator.modelOutput))) - .select(true, Variant.variant().with(VariantProperties.MODEL, formed))); - - generator.blockStateOutput.accept(craftingUnit); - generator.modelOutput.accept(formed, () -> customModelLoader(formed)); - generator.delegateItemModel(block, unformed); - } - - private void craftingMonitor(BlockModelGenerators generator) { - var unformed = MEGACells.makeId("block/crafting/monitor"); - var unit = MEGACells.makeId("block/crafting/unit"); - var unformedModel = ModelTemplates.CUBE.create( - unformed, - new TextureMapping() - .put(TextureSlot.NORTH, unformed) - .put(TextureSlot.EAST, unit) - .put(TextureSlot.SOUTH, unit) - .put(TextureSlot.WEST, unit) - .put(TextureSlot.DOWN, unit) - .put(TextureSlot.UP, unit) - .put(TextureSlot.PARTICLE, unformed), - generator.modelOutput); - - var formedModel = MEGACells.makeId("block/crafting/monitor_formed"); - generator.blockStateOutput.accept(MultiVariantGenerator.multiVariant(MEGABlocks.CRAFTING_MONITOR.block()) - .with(PropertyDispatch.properties(AbstractCraftingUnitBlock.FORMED, BlockStateProperties.FACING) - .generate((formed, facing) -> { - if (formed) { - return Variant.variant().with(VariantProperties.MODEL, formedModel); - } else { - return applyOrientation( - Variant.variant().with(VariantProperties.MODEL, unformedModel), - BlockOrientation.get(facing)); - } - }))); - generator.modelOutput.accept(formedModel, () -> customModelLoader(formedModel)); - generator.delegateItemModel(MEGABlocks.CRAFTING_MONITOR.block(), unformed); - } - - private JsonObject customModelLoader(ResourceLocation loc) { - var json = new JsonObject(); - json.addProperty("loader", loc.toString()); - return json; - } - - private void patternProviderBlock(BlockModelGenerators generator) { - var normal = ModelTemplates.CUBE_ALL.create( - MEGABlocks.MEGA_PATTERN_PROVIDER.block(), - TextureMapping.cube(MEGABlocks.MEGA_PATTERN_PROVIDER.block()), - generator.modelOutput); - var oriented = ModelTemplates.CUBE.create( - MEGACells.makeId("block/mega_pattern_provider_oriented"), - new TextureMapping() - .put(TextureSlot.UP, MEGACells.makeId("block/mega_pattern_provider_alternate_front")) - .put(TextureSlot.DOWN, MEGACells.makeId("block/mega_pattern_provider_alternate")) - .put(TextureSlot.NORTH, MEGACells.makeId("block/mega_pattern_provider_alternate_arrow")) - .copySlot(TextureSlot.NORTH, TextureSlot.EAST) - .copySlot(TextureSlot.NORTH, TextureSlot.SOUTH) - .copySlot(TextureSlot.NORTH, TextureSlot.WEST) - .put(TextureSlot.PARTICLE, normal), - generator.modelOutput); - - generator.blockStateOutput.accept(MultiVariantGenerator.multiVariant(MEGABlocks.MEGA_PATTERN_PROVIDER.block()) - .with(PropertyDispatch.property(PatternProviderBlock.PUSH_DIRECTION) - .generate(pushDirection -> { - var forward = pushDirection.getDirection(); - - if (forward == null) { - return Variant.variant().with(VariantProperties.MODEL, normal); - } else { - var orientation = BlockOrientation.get(forward); - return applyRotation( - Variant.variant().with(VariantProperties.MODEL, oriented), - // + 90 because the default model is oriented UP, while block orientation - // assumes NORTH - orientation.getAngleX() + 90, - orientation.getAngleY(), - 0); - } - }))); - - generator.delegateItemModel(MEGABlocks.MEGA_PATTERN_PROVIDER.block(), normal); - } - - protected Variant applyOrientation(Variant variant, BlockOrientation orientation) { - return applyRotation(variant, orientation.getAngleX(), orientation.getAngleY(), orientation.getAngleZ()); - } - - protected Variant applyRotation(Variant variant, int angleX, int angleY, int angleZ) { - angleX = normalizeAngle(angleX); - angleY = normalizeAngle(angleY); - angleZ = normalizeAngle(angleZ); - - if (angleX != 0) { - variant = variant.with(VariantProperties.X_ROT, rotationByAngle(angleX)); - } - if (angleY != 0) { - variant = variant.with(VariantProperties.Y_ROT, rotationByAngle(angleY)); - } - if (angleZ != 0) { - variant = variant.with(Z_ROT, rotationByAngle(angleZ)); - } - return variant; - } - - private int normalizeAngle(int angle) { - return angle - (angle / 360) * 360; - } - - private VariantProperties.Rotation rotationByAngle(int angle) { - return switch (angle) { - case 0 -> VariantProperties.Rotation.R0; - case 90 -> VariantProperties.Rotation.R90; - case 180 -> VariantProperties.Rotation.R180; - case 270 -> VariantProperties.Rotation.R270; - default -> throw new IllegalArgumentException("Invalid angle: " + angle); - }; - } - - private void interfaceOrProviderPart(ItemModelGenerators generator, ItemDefinition part) { - var partName = part.id().getPath().substring(6); - var front = MEGACells.makeId("part/" + partName); - var back = MEGACells.makeId("part/" + partName + "_back"); - var sides = MEGACells.makeId("part/" + partName + "_sides"); - INTERFACE.create( - MEGACells.makeId("part/" + partName), - new TextureMapping() - .put(SIDES_STATUS, MEGACells.makeId("part/mega_monitor_sides_status")) - .put(SIDES, sides) - .put(TextureSlot.BACK, back) - .put(TextureSlot.FRONT, front) - .put(TextureSlot.PARTICLE, back), - generator.output); - CABLE_INTERFACE.create( - MEGACells.makeId("item/" + part.id().getPath()), - new TextureMapping() - .put(SIDES, sides) - .put(TextureSlot.FRONT, front) - .put(TextureSlot.BACK, back), - generator.output); - } - - private void energyCell(BlockModelGenerators generator) { - var cell = MEGABlocks.MEGA_ENERGY_CELL; - var fillStage = PropertyDispatch.property(EnergyCellBlock.ENERGY_STORAGE); - List> itemModelOverrides = new ArrayList<>(); - - for (var i = 0; i < 5; i++) { - fillStage.select( - i, - Variant.variant() - .with( - VariantProperties.MODEL, - generator.createSuffixedVariant( - cell.block(), "_" + i, ModelTemplates.CUBE_ALL, TextureMapping::cube))); - if (i < 4) { - var fillPredicate = new JsonObject(); - fillPredicate.addProperty("ae2:fill_level", 0.25 * i); - itemModelOverrides.add( - Pair.of(MEGACells.makeId("block/" + cell.id().getPath() + "_" + (i + 1)), fillPredicate)); - } - } - - generator.blockStateOutput.accept( - MultiVariantGenerator.multiVariant(cell.block()).with(fillStage)); - generator.modelOutput.accept( - MEGACells.makeId("item/" + cell.id().getPath()), - new OverrideableDelegatedModel( - MEGACells.makeId("block/" + cell.id().getPath() + "_0"), itemModelOverrides)); - } - - static class OverrideableDelegatedModel extends DelegatedModel { - private final List> overrides; - - public OverrideableDelegatedModel( - ResourceLocation resourceLocation, List> overrides) { - super(resourceLocation); - this.overrides = overrides; - } - - @NotNull - @Override - public JsonElement get() { - JsonObject json = super.get().getAsJsonObject(); - - JsonArray array = new JsonArray(); - for (var override : this.overrides) { - JsonObject entry = new JsonObject(); - entry.addProperty("model", override.first.toString()); - entry.add("predicate", override.second); - array.add(entry); - } - - json.add("overrides", array); - return json; - } - } -} diff --git a/forge/src/data/java/gripe/_90/megacells/datagen/ForgeModelProvider.java b/forge/src/data/java/gripe/_90/megacells/datagen/ForgeModelProvider.java new file mode 100644 index 00000000..0c1b302b --- /dev/null +++ b/forge/src/data/java/gripe/_90/megacells/datagen/ForgeModelProvider.java @@ -0,0 +1,54 @@ +package gripe._90.megacells.datagen; + +import net.minecraft.data.PackOutput; +import net.minecraft.resources.ResourceLocation; +import net.minecraftforge.client.model.generators.ItemModelProvider; +import net.minecraftforge.common.data.ExistingFileHelper; + +import appeng.core.AppEng; +import appeng.core.definitions.ItemDefinition; + +import gripe._90.megacells.MEGACells; +import gripe._90.megacells.core.Addons; +import gripe._90.megacells.integration.appmek.AppMekItems; + +class ForgeModelProvider extends ItemModelProvider { + private static final ResourceLocation STORAGE_CELL_LED = AppEng.makeId("item/storage_cell_led"); + private static final ResourceLocation PORTABLE_CELL_LED = AppEng.makeId("item/portable_cell_led"); + + private static final ResourceLocation DRIVE_CELL = AppEng.makeId("block/drive/drive_cell"); + + public ForgeModelProvider(PackOutput output, ExistingFileHelper existing) { + super(output, MEGACells.MODID, existing); + existing.trackGenerated(STORAGE_CELL_LED, TEXTURE); + existing.trackGenerated(PORTABLE_CELL_LED, TEXTURE); + existing.trackGenerated(DRIVE_CELL, MODEL); + } + + @Override + protected void registerModels() { + if (MEGACells.PLATFORM.isAddonLoaded(Addons.APPMEK)) { + basicItem(AppMekItems.MEGA_CHEMICAL_CELL_HOUSING.asItem()); + + AppMekItems.getCells().forEach(c -> cell(c, "standard", STORAGE_CELL_LED)); + AppMekItems.getPortables().forEach(c -> cell(c, "portable", PORTABLE_CELL_LED)); + + basicItem(AppMekItems.RADIOACTIVE_CELL_COMPONENT.asItem()); + cell(AppMekItems.RADIOACTIVE_CHEMICAL_CELL, "standard", STORAGE_CELL_LED); + + driveCell("mega_chemical_cell"); + driveCell("radioactive_chemical_cell"); + } + } + + private void cell(ItemDefinition cell, String type, ResourceLocation led) { + var path = cell.id().getPath(); + singleTexture(path, mcLoc("item/generated"), "layer0", MEGACells.makeId("item/cell/" + type + "/" + path)) + .texture("layer1", led); + } + + private void driveCell(String texture) { + var path = "block/drive/cells/" + texture; + withExistingParent(path, DRIVE_CELL).texture("cell", path); + } +} diff --git a/forge/src/data/java/gripe/_90/megacells/datagen/MEGADataGenerators.java b/forge/src/data/java/gripe/_90/megacells/datagen/MEGADataGenerators.java index 1c7ad250..0ba014be 100644 --- a/forge/src/data/java/gripe/_90/megacells/datagen/MEGADataGenerators.java +++ b/forge/src/data/java/gripe/_90/megacells/datagen/MEGADataGenerators.java @@ -14,19 +14,16 @@ public static void onGatherData(GatherDataEvent event) { var generator = event.getGenerator(); var output = generator.getPackOutput(); - var existing = event.getExistingFileHelper(); - generator.addProvider(event.includeClient(), new ModelProvider.Items(output, existing)); - generator.addProvider(event.includeClient(), new ModelProvider.Blocks(output, existing)); - generator.addProvider(event.includeClient(), new ModelProvider.Parts(output, existing)); - var registries = event.getLookupProvider(); generator.addProvider(event.includeServer(), new CommonTagProvider.BlockTags(output, registries)); generator.addProvider(event.includeServer(), new CommonTagProvider.ItemTags(output, registries)); + generator.addProvider(event.includeClient(), new CommonModelProvider(output)); generator.addProvider(event.includeClient(), new CommonLanguageProvider(output)); generator.addProvider(event.includeServer(), new CommonLootTableProvider(output)); generator.addProvider(event.includeServer(), new CommonRecipeProvider(output)); generator.addProvider(event.includeServer(), new ForgeRecipeProvider(output)); + generator.addProvider(event.includeClient(), new ForgeModelProvider(output, event.getExistingFileHelper())); } } diff --git a/forge/src/data/java/gripe/_90/megacells/datagen/ModelProvider.java b/forge/src/data/java/gripe/_90/megacells/datagen/ModelProvider.java deleted file mode 100644 index 9601049a..00000000 --- a/forge/src/data/java/gripe/_90/megacells/datagen/ModelProvider.java +++ /dev/null @@ -1,331 +0,0 @@ -package gripe._90.megacells.datagen; - -import java.util.ArrayList; -import java.util.List; - -import com.ibm.icu.impl.Pair; - -import org.jetbrains.annotations.NotNull; - -import net.minecraft.data.PackOutput; -import net.minecraft.data.models.blockstates.PropertyDispatch; -import net.minecraft.data.models.blockstates.Variant; -import net.minecraft.data.models.blockstates.VariantProperties; -import net.minecraft.resources.ResourceLocation; -import net.minecraft.world.level.block.state.properties.BlockStateProperties; -import net.minecraftforge.client.model.generators.BlockModelBuilder; -import net.minecraftforge.client.model.generators.ConfiguredModel; -import net.minecraftforge.client.model.generators.ItemModelProvider; -import net.minecraftforge.client.model.generators.ModelFile; -import net.minecraftforge.common.data.ExistingFileHelper; - -import appeng.api.orientation.BlockOrientation; -import appeng.block.crafting.AbstractCraftingUnitBlock; -import appeng.block.crafting.PatternProviderBlock; -import appeng.block.networking.EnergyCellBlock; -import appeng.core.AppEng; -import appeng.core.definitions.BlockDefinition; -import appeng.core.definitions.ItemDefinition; -import appeng.datagen.providers.models.AE2BlockStateProvider; -import appeng.init.client.InitItemModelsProperties; - -import gripe._90.megacells.MEGACells; -import gripe._90.megacells.core.Addons; -import gripe._90.megacells.definition.MEGABlocks; -import gripe._90.megacells.definition.MEGAItems; -import gripe._90.megacells.integration.appbot.AppBotItems; -import gripe._90.megacells.integration.appmek.AppMekItems; - -abstract class ModelProvider { - static class Items extends ItemModelProvider { - private static final ResourceLocation CRAFTING_PATTERN = AppEng.makeId("item/crafting_pattern"); - - private static final ResourceLocation STORAGE_CELL_LED = AppEng.makeId("item/storage_cell_led"); - private static final ResourceLocation PORTABLE_CELL_LED = AppEng.makeId("item/portable_cell_led"); - - private static final ResourceLocation PORTABLE_CELL_ITEM_HOUSING = - AppEng.makeId("item/portable_cell_item_housing"); - private static final ResourceLocation PORTABLE_CELL_FLUID_HOUSING = - AppEng.makeId("item/portable_cell_fluid_housing"); - - private static final ResourceLocation CABLE_INTERFACE = AppEng.makeId("item/cable_interface"); - private static final ResourceLocation DRIVE_CELL = AppEng.makeId("block/drive/drive_cell"); - - public Items(PackOutput output, ExistingFileHelper existing) { - super(output, MEGACells.MODID, existing); - existing.trackGenerated(CRAFTING_PATTERN, TEXTURE); - existing.trackGenerated(STORAGE_CELL_LED, TEXTURE); - existing.trackGenerated(PORTABLE_CELL_LED, TEXTURE); - existing.trackGenerated(PORTABLE_CELL_ITEM_HOUSING, TEXTURE); - existing.trackGenerated(PORTABLE_CELL_FLUID_HOUSING, TEXTURE); - existing.trackGenerated(CABLE_INTERFACE, MODEL); - existing.trackGenerated(DRIVE_CELL, MODEL); - } - - @Override - protected void registerModels() { - basicItem(MEGAItems.SKY_STEEL_INGOT.asItem()); - - basicItem(MEGAItems.ACCUMULATION_PROCESSOR_PRESS.asItem()); - basicItem(MEGAItems.ACCUMULATION_PROCESSOR_PRINT.asItem()); - basicItem(MEGAItems.ACCUMULATION_PROCESSOR.asItem()); - - basicItem(MEGAItems.MEGA_ITEM_CELL_HOUSING.asItem()); - basicItem(MEGAItems.MEGA_FLUID_CELL_HOUSING.asItem()); - - basicItem(MEGAItems.CELL_COMPONENT_1M.asItem()); - basicItem(MEGAItems.CELL_COMPONENT_4M.asItem()); - basicItem(MEGAItems.CELL_COMPONENT_16M.asItem()); - basicItem(MEGAItems.CELL_COMPONENT_64M.asItem()); - basicItem(MEGAItems.CELL_COMPONENT_256M.asItem()); - basicItem(MEGAItems.BULK_CELL_COMPONENT.asItem()); - - basicItem(MEGAItems.GREATER_ENERGY_CARD.asItem()); - basicItem(MEGAItems.COMPRESSION_CARD.asItem()); - - singleTexture( - MEGAItems.DECOMPRESSION_PATTERN.id().getPath(), - mcLoc("item/generated"), - "layer0", - CRAFTING_PATTERN); - - MEGAItems.getItemPortables().forEach(p -> portableModel(p, "item", PORTABLE_CELL_ITEM_HOUSING)); - MEGAItems.getFluidPortables().forEach(p -> portableModel(p, "fluid", PORTABLE_CELL_FLUID_HOUSING)); - - driveCell("mega_item_cell"); - driveCell("mega_fluid_cell"); - driveCell("bulk_item_cell"); - - var cells = new ArrayList<>(MEGAItems.getItemCells()); - cells.addAll(MEGAItems.getFluidCells()); - cells.add(MEGAItems.BULK_ITEM_CELL); - - if (MEGACells.PLATFORM.isAddonLoaded(Addons.APPMEK)) { - basicItem(AppMekItems.MEGA_CHEMICAL_CELL_HOUSING.asItem()); - - cells.addAll(AppMekItems.getCells()); - AppMekItems.getPortables().forEach(this::portableChemCell); - - basicItem(AppMekItems.RADIOACTIVE_CELL_COMPONENT.asItem()); - cells.add(AppMekItems.RADIOACTIVE_CHEMICAL_CELL); - - driveCell("mega_chemical_cell"); - driveCell("radioactive_chemical_cell"); - } - - if (MEGACells.PLATFORM.isAddonLoaded(Addons.APPBOT)) { - basicItem(AppBotItems.MEGA_MANA_CELL_HOUSING.asItem()); - - cells.addAll(AppBotItems.getCells()); - // TODO - AppBotItems.getPortables().forEach(p -> portableModel(p, "mana", PORTABLE_CELL_ITEM_HOUSING)); - - driveCell("mega_mana_cell"); - } - - cells.forEach(this::cellModel); - - interfaceOrProviderPart(MEGAItems.MEGA_INTERFACE); - interfaceOrProviderPart(MEGAItems.MEGA_PATTERN_PROVIDER); - } - - private void cellModel(ItemDefinition cell) { - var path = cell.id().getPath(); - singleTexture(path, mcLoc("item/generated"), "layer0", MEGACells.makeId("item/cell/standard/" + path)) - .texture("layer1", STORAGE_CELL_LED); - } - - private void portableModel(ItemDefinition portable, String screenType, ResourceLocation housingTexture) { - var path = portable.id().getPath(); - var tierSuffix = path.substring(path.lastIndexOf('_') + 1); - singleTexture( - path, - mcLoc("item/generated"), - "layer0", - MEGACells.makeId("item/cell/portable/portable_cell_%s_screen".formatted(screenType))) - .texture("layer1", PORTABLE_CELL_LED) - .texture("layer2", housingTexture) - .texture("layer3", "item/cell/portable/portable_cell_side_%s".formatted(tierSuffix)); - } - - private void portableChemCell(ItemDefinition portable) { - singleTexture( - portable.id().getPath(), - mcLoc("item/generated"), - "layer0", - MEGACells.makeId( - "item/cell/portable/" + portable.id().getPath())) - .texture("layer1", PORTABLE_CELL_LED); - } - - private void driveCell(String texture) { - var path = "block/drive/cells/" + texture; - withExistingParent(path, DRIVE_CELL).texture("cell", path); - } - - private void interfaceOrProviderPart(ItemDefinition part) { - var partPath = part.id().getPath().substring(6); - withExistingParent(part.id().getPath(), CABLE_INTERFACE) - .texture("back", "part/" + partPath + "_back") - .texture("front", "part/" + partPath) - .texture("sides", "part/" + partPath + "_sides"); - } - } - - static class Blocks extends AE2BlockStateProvider { - public Blocks(PackOutput output, ExistingFileHelper existing) { - super(output, MEGACells.MODID, existing); - } - - @Override - protected void registerStatesAndModels() { - simpleBlockAndItem(MEGABlocks.SKY_STEEL_BLOCK); - simpleBlockAndItem(MEGABlocks.MEGA_INTERFACE); - - energyCell(); - patternProvider(); - - var craftingUnits = List.of( - Pair.of(MEGABlocks.MEGA_CRAFTING_UNIT, "unit"), - Pair.of(MEGABlocks.CRAFTING_STORAGE_1M, "1m_storage"), - Pair.of(MEGABlocks.CRAFTING_STORAGE_4M, "4m_storage"), - Pair.of(MEGABlocks.CRAFTING_STORAGE_16M, "16m_storage"), - Pair.of(MEGABlocks.CRAFTING_STORAGE_64M, "64m_storage"), - Pair.of(MEGABlocks.CRAFTING_STORAGE_256M, "256m_storage"), - Pair.of(MEGABlocks.CRAFTING_ACCELERATOR, "accelerator")); - craftingUnits.forEach(block -> craftingModel(block.first, block.second)); - craftingMonitor(); - } - - private void energyCell() { - var cell = MEGABlocks.MEGA_ENERGY_CELL; - var path = cell.id().getPath(); - var blockBuilder = getVariantBuilder(cell.block()); - var models = new ArrayList(); - - for (var i = 0; i < 5; i++) { - var model = models().cubeAll(path + "_" + i, MEGACells.makeId("block/" + path + "_" + i)); - blockBuilder - .partialState() - .with(EnergyCellBlock.ENERGY_STORAGE, i) - .setModels(new ConfiguredModel(model)); - models.add(model); - } - - var item = itemModels().withExistingParent(path, models.get(0).getLocation()); - - for (var i = 1; i < models.size(); i++) { - float fillFactor = i / (float) models.size(); - item.override() - .predicate(InitItemModelsProperties.ENERGY_FILL_LEVEL_ID, fillFactor) - .model(models.get(i)); - } - } - - private void craftingModel(BlockDefinition block, String name) { - var blockModel = models().cubeAll("block/crafting/" + name, MEGACells.makeId("block/crafting/" + name)); - getVariantBuilder(block.block()) - .partialState() - .with(AbstractCraftingUnitBlock.FORMED, false) - .setModels(new ConfiguredModel(blockModel)) - .partialState() - .with(AbstractCraftingUnitBlock.FORMED, true) - .setModels(new ConfiguredModel(models().getBuilder("block/crafting/" + name + "_formed"))); - simpleBlockItem(block.block(), blockModel); - } - - private void craftingMonitor() { - models().getBuilder("block/crafting/monitor_formed"); - - var monitor = MEGACells.makeId("block/crafting/monitor"); - var unit = MEGACells.makeId("block/crafting/unit"); - var unformedModel = models().cube("block/crafting/mega_monitor", unit, unit, monitor, unit, unit, unit) - .texture("particle", monitor); - - multiVariantGenerator(MEGABlocks.CRAFTING_MONITOR) - .with(PropertyDispatch.properties(AbstractCraftingUnitBlock.FORMED, BlockStateProperties.FACING) - .generate((formed, facing) -> { - if (formed) { - return Variant.variant() - .with( - VariantProperties.MODEL, - MEGACells.makeId("block/crafting/monitor_formed")); - } else { - return applyOrientation( - Variant.variant() - .with(VariantProperties.MODEL, unformedModel.getLocation()), - BlockOrientation.get(facing)); - } - })); - - simpleBlockItem(MEGABlocks.CRAFTING_MONITOR.block(), unformedModel); - } - - private void patternProvider() { - var def = MEGABlocks.MEGA_PATTERN_PROVIDER; - var normalModel = cubeAll(def.block()); - simpleBlockItem(def.block(), normalModel); - - var arrow = MEGACells.makeId("block/mega_pattern_provider_alternate_arrow"); - var orientedModel = models().cube( - "block/mega_pattern_provider_oriented", - MEGACells.makeId("block/mega_pattern_provider_alternate"), - MEGACells.makeId("block/mega_pattern_provider_alternate_front"), - arrow, - arrow, - arrow, - arrow) - .texture("particle", "block/mega_pattern_provider"); - - multiVariantGenerator(MEGABlocks.MEGA_PATTERN_PROVIDER, Variant.variant()) - .with(PropertyDispatch.property(PatternProviderBlock.PUSH_DIRECTION) - .generate(pushDirection -> { - var forward = pushDirection.getDirection(); - if (forward == null) { - return Variant.variant().with(VariantProperties.MODEL, normalModel.getLocation()); - } else { - var orientation = BlockOrientation.get(forward); - return applyRotation( - Variant.variant() - .with(VariantProperties.MODEL, orientedModel.getLocation()), - // + 90 because the default model is oriented UP, while block orientation - // assumes NORTH - orientation.getAngleX() + 90, - orientation.getAngleY(), - 0); - } - })); - } - } - - static class Parts extends net.minecraftforge.client.model.generators.ModelProvider { - private static final ResourceLocation INTERFACE = AppEng.makeId("part/interface_base"); - - public Parts(PackOutput output, ExistingFileHelper existing) { - super(output, MEGACells.MODID, "part", BlockModelBuilder::new, existing); - existing.trackGenerated(INTERFACE, MODEL); - } - - @NotNull - @Override - public String getName() { - return "Part Models: " + modid; - } - - @Override - protected void registerModels() { - interfaceOrPatternProvider(MEGAItems.MEGA_INTERFACE); - interfaceOrPatternProvider(MEGAItems.MEGA_PATTERN_PROVIDER); - } - - private void interfaceOrPatternProvider(ItemDefinition part) { - var partName = part.id().getPath().substring(6); - withExistingParent("part/" + partName, INTERFACE) - .texture("back", "part/" + partName + "_back") - .texture("front", "part/" + partName) - .texture("particle", "part/" + partName + "_back") - .texture("sides", "part/" + partName + "_sides") - .texture("sidesStatus", "part/mega_monitor_sides_status"); - } - } -} diff --git a/forge/src/data/java/gripe/_90/megacells/mixin/data/MainMixin.java b/forge/src/data/java/gripe/_90/megacells/mixin/data/forge/MainMixin.java similarity index 92% rename from forge/src/data/java/gripe/_90/megacells/mixin/data/MainMixin.java rename to forge/src/data/java/gripe/_90/megacells/mixin/data/forge/MainMixin.java index 3ffbd8b2..214e2752 100644 --- a/forge/src/data/java/gripe/_90/megacells/mixin/data/MainMixin.java +++ b/forge/src/data/java/gripe/_90/megacells/mixin/data/forge/MainMixin.java @@ -1,4 +1,4 @@ -package gripe._90.megacells.mixin.data; +package gripe._90.megacells.mixin.data.forge; import org.spongepowered.asm.mixin.Mixin; import org.spongepowered.asm.mixin.injection.At; diff --git a/forge/src/data/resources/megacells.data.mixins.json b/forge/src/data/resources/megacells.data.mixins.json index 6db3718d..5f2f0628 100644 --- a/forge/src/data/resources/megacells.data.mixins.json +++ b/forge/src/data/resources/megacells.data.mixins.json @@ -3,7 +3,7 @@ "minVersion": "0.8", "package": "gripe._90.megacells.mixin.data", "compatibilityLevel": "JAVA_17", - "mixins": ["MainMixin"], + "mixins": ["TextureSlotAccessor", "forge.MainMixin"], "injectors": { "defaultRequire": 1 }