Custom Recipes for Create: Data Generation and Processing

/**
 * A class containing basic setup for recipe generators.
 * Extend this if you have a custom recipe type that is NOT a processing recipe.
 * For processing recipes, extend {@link StandardProcessingRecipeGen} instead.
 */
public abstract class BaseRecipeProvider extends RecipeProvider {

    /** The mod namespace used for generated recipe resource locations. */
    protected final String modid;

    /**
     * All registered GeneratedRecipe instances. buildRecipes() calls each in order.
     */
    protected final List<GeneratedRecipe> all = new ArrayList<>();

    public BaseRecipeProvider(PackOutput output,
                              CompletableFuture<HolderLookup.Provider> registries,
                              String defaultNamespace) { ... }

    /** Build a ResourceLocation in this provider's namespace. */
    protected ResourceLocation asResource(String path) { ... }

    /** Register a recipe for generation. Returns the recipe for chaining. */
    protected GeneratedRecipe register(GeneratedRecipe recipe) { ... }

    @Override
    public void buildRecipes(RecipeOutput recipeOutput) {
        // Calls register() on every GeneratedRecipe, then logs the count.
    }

    @FunctionalInterface
    public interface GeneratedRecipe {
        void register(RecipeOutput recipeOutput);
    }
}

public class MyRecipeProvider extends BaseRecipeProvider {

    public MyRecipeProvider(PackOutput output,
                            CompletableFuture<HolderLookup.Provider> registries) {
        super(output, registries, "mymod");
    }

    @Override
    public String getName() {
        return "My Mod Recipes";
    }

    // Register individual GeneratedRecipe lambdas here using the `register()` helper.
}

public abstract class StandardProcessingRecipeGen<R extends StandardProcessingRecipe<?>>
    extends ProcessingRecipeGen<ProcessingRecipeParams, R, StandardProcessingRecipe.Builder<R>> {

    public StandardProcessingRecipeGen(PackOutput output,
                                       CompletableFuture<Provider> registries,
                                       String defaultNamespace) { ... }

    /** Return the serializer for recipe type R. Used internally. */
    protected StandardProcessingRecipe.Serializer<R> getSerializer() { ... }

    @Override
    protected Builder<R> getBuilder(ResourceLocation id) { ... }
}

/**
 * Base class for Compacting recipe generation.
 * Extend this and use ProcessingRecipeGen#create() to build recipes.
 * Needs to be added to a registered recipe provider to do anything.
 */
public abstract class CompactingRecipeGen
    extends StandardProcessingRecipeGen<CompactingRecipe> {

    public CompactingRecipeGen(PackOutput output,
                               CompletableFuture<HolderLookup.Provider> registries,
                               String defaultNamespace) { ... }

    @Override
    protected AllRecipeTypes getRecipeType() {
        return AllRecipeTypes.COMPACTING;
    }
}

@SubscribeEvent
public static void onGatherData(GatherDataEvent event) {
    DataGenerator generator = event.getGenerator();
    PackOutput output = generator.getPackOutput();
    CompletableFuture<HolderLookup.Provider> registries = event.getLookupProvider();

    // Non-processing recipe provider:
    generator.addProvider(
        event.includeServer(),
        new MyRecipeProvider(output, registries)
    );

    // Processing recipe provider (e.g. compacting):
    generator.addProvider(
        event.includeServer(),
        new MyCompactingRecipes(output, registries)
    );
}