Java 类net.minecraftforge.fml.common.ProgressManager 实例源码

@SubscribeEvent (priority = EventPriority.HIGHEST)
public void onModelBake(ModelBakeEvent event) {

    IModel missingIModel = ModelLoaderRegistry.getMissingModel();
    IBakedModel missingModel = missingIModel.bake(missingIModel.getDefaultState(), DefaultVertexFormats.ITEM, TextureUtils.bakedTextureGetter);
    Map<IModel, IBakedModel> bakedModels = new HashMap<>();
    HashMultimap<IModel, ModelResourceLocation> models = HashMultimap.create();
    Multimaps.invertFrom(Multimaps.forMap(toBake), models);

    ProgressBar bar = ProgressManager.push("CCL ModelLoading: Baking", models.keySet().size());

    for (IModel model : models.keySet()) {
        bar.step(String.format("[%s]", Joiner.on(", ").join(models.get(model))));
        if (model == missingIModel) {
            bakedModels.put(model, missingModel);
            continue;
        }
        bakedModels.put(model, model.bake(model.getDefaultState(), DefaultVertexFormats.ITEM, TextureUtils.bakedTextureGetter));
    }
    ProgressManager.pop(bar);

    for (Entry<ModelResourceLocation, IModel> entry : toBake.entrySet()) {
        event.getModelRegistry().putObject(entry.getKey(), bakedModels.get(entry.getValue()));
    }

}

public void processSetFiles() {
    if(setFiles.size() <= 0) return;

    // > Be fancy.
    ProgressBar setProgress = ProgressManager.push("Processing", setFiles.size());

    for(File config : setFiles) {
        setProgress.step(config.getName());
        LogHelper.info("Reading " + config.getPath());
        try {
            NashornConfigProcessor.getInstance().ReadConfigFile(config);
        } catch (Exception e) {
            LogHelper.error("Error processing file " + config.getPath() + ": " + e.getMessage());
        }
    }

    // > Stop being fancy
    ProgressManager.pop(setProgress);
}

@Mod.EventHandler
public void init(FMLInitializationEvent evt) {
    try {
        proxy.init(evt);
        nativeConverters.stream().forEachOrdered(forgeLoadable -> forgeLoadable.init(evt));
        ProgressManager.ProgressBar progressBar = ProgressManager.push("Initializing NOVA wrappers", (novaModWrappers.isEmpty() ? 1 : novaModWrappers.size()) + novaWrappers.size());
        FMLProgressBar fmlProgressBar = new FMLProgressBar(progressBar);
        novaModWrappers.stream().forEachOrdered(wrapper -> {
            fmlProgressBar.step(wrapper.getClass());
            wrapper.init(evt);
        });
        novaWrappers.stream().forEachOrdered(wrapper -> {
            fmlProgressBar.step(wrapper.getClass());
            wrapper.init(evt);
        });
        fmlProgressBar.finish();
        ProgressManager.pop(progressBar);
    } catch (Exception e) {
        Game.logger().error("Error during init", e);
        e.printStackTrace();
        throw new InitializationException(e);
    }
}

@Mod.EventHandler
public void postInit(FMLPostInitializationEvent evt) {
    try {
        proxy.postInit(evt);
        nativeConverters.stream().forEachOrdered(forgeLoadable -> forgeLoadable.postInit(evt));
        Game.recipes().init();
        ProgressManager.ProgressBar progressBar = ProgressManager.push("Post-initializing NOVA wrappers", (novaModWrappers.isEmpty() ? 1 : novaModWrappers.size()) + novaWrappers.size());
        FMLProgressBar fmlProgressBar = new FMLProgressBar(progressBar);
        novaModWrappers.stream().forEachOrdered(wrapper -> {
            fmlProgressBar.step(wrapper.getClass());
            wrapper.postInit(evt);
        });
        novaWrappers.stream().forEachOrdered(wrapper -> {
            fmlProgressBar.step(wrapper.getClass());
            wrapper.postInit(evt);
        });
        fmlProgressBar.finish();
        ProgressManager.pop(progressBar);
    } catch (Exception e) {
        Game.logger().error("Error during postInit", e);
        e.printStackTrace();
        throw new InitializationException(e);
    }
}

@Override
public void onResourceManagerReload(@Nullable IResourceManager resourceManager) {
    ProgressManager.ProgressBar bar = ProgressManager.push("Reloading Sprite Manager", 0);
    reloading = true;
    for(Map.Entry<ResourceLocation, SpriteResource> entry : SPRITE_RESOURCE_MAP.entrySet()) {
        SpriteResource bind = entry.getValue();
        bind.reload();
    }
    reloading = false;
    ProgressManager.pop(bar);
}

@Override
public void onResourceManagerReload(IResourceManager manager) {
    ProgressManager.ProgressBar bar = ProgressManager.push("Reloading Shader Manager", 0);
    reloading = true;
    SHADER_RESOURCES.forEach(shader -> shader.reload(manager));
    reloading = false;
    ProgressManager.pop(bar);
}

/***
 * loadRegisteredPatterns() is called on onFMLInitialization after all blocks have been loaded. This allows for
 * cross-mod blocks to be used within the structure.
 */
public static void loadRegisteredPatterns()
{
    final ProgressBar blockBar = ProgressManager.push("Structure", registeredStructures.size());

    for (final Pair<StructureBlock, StructureShapeBlock> strucPair : registeredStructures)
    {
        final StructureBlock block  = strucPair.first();

        blockBar.step(block.getLocalizedName());

        try
        {
            block.setStructureDefinition(
                    block.getStructureBuild().build(),
                    strucPair.second(),
                    block.getUnlocalizedName().hashCode()
            );

            structures.put(block.getUnlocalizedName().hashCode(), block);
        } catch (StructureDefinitionError e)
        {
            throw new StructureDefinitionError(e.getMessage() + " on '" + block.getUnlocalizedName() + '\'');
        }
    }

    ProgressManager.pop(blockBar);

    //StructureLogger.info("Analytical Engine constructed " + structures.size() + " noteworthy contraptions");
}

static void loadModels() {
    ProgressManager.ProgressBar progressBarModels;
    progressBarModels = ProgressManager.push("Registry Models", CSRegistryHelper.loadModelList.size());

    for (LoadElement el : CSRegistryHelper.loadModelList) {
        progressBarModels.step("[" + el.resourceLoc.getResourceDomain() + ":" + el.ressourceName + "]");
        registry(EnumResourceType.MODEL, el.resourceLoc, el.ressourceName);
    }
    ProgressManager.pop(progressBarModels);

    CraftStudioApi.getLogger().info(String.format("CraftStudioAPI loaded %s models", CSRegistryHelper.loadModelList.size()));
    CSRegistryHelper.loadModelList = null;
}

static void loadAnims() {
    ProgressManager.ProgressBar progressBarAnim;
    progressBarAnim = ProgressManager.push("Registry Animations", CSRegistryHelper.loadAnimList.size());
    for (LoadElement el : CSRegistryHelper.loadAnimList) {
        progressBarAnim.step("[" + el.resourceLoc.getResourceDomain() + ":" + el.ressourceName + "]");
        registry(EnumResourceType.ANIM, el.resourceLoc, el.ressourceName);
    }
    ProgressManager.pop(progressBarAnim);

    CraftStudioApi.getLogger().info(String.format("CraftStudioAPI loaded %s animations", CSRegistryHelper.loadAnimList.size()));
    CSRegistryHelper.loadAnimList = null;
}

public static void saveGlTexture(String name, int textureId, int mipmapLevels, File outputFolder) {
    GL11.glBindTexture(GL11.GL_TEXTURE_2D, textureId);

    GL11.glPixelStorei(GL11.GL_PACK_ALIGNMENT, 1);
    GL11.glPixelStorei(GL11.GL_UNPACK_ALIGNMENT, 1);

    ProgressManager.ProgressBar progressBar = ProgressManager.push("Dumping TextureMap to file", mipmapLevels + 1);

    for (int level = 0; level <= mipmapLevels; level++) {
        int width = GL11.glGetTexLevelParameteri(GL11.GL_TEXTURE_2D, level, GL11.GL_TEXTURE_WIDTH);
        int height = GL11.glGetTexLevelParameteri(GL11.GL_TEXTURE_2D, level, GL11.GL_TEXTURE_HEIGHT);
        int size = width * height;

        BufferedImage bufferedimage = new BufferedImage(width, height, 2);
        String fileName = name + "_mipmap_" + level + ".png";
        progressBar.step(fileName);

        File output = new File(outputFolder, fileName);
        IntBuffer buffer = BufferUtils.createIntBuffer(size);
        int[] data = new int[size];

        GL11.glGetTexImage(GL11.GL_TEXTURE_2D, level, GL12.GL_BGRA, GL12.GL_UNSIGNED_INT_8_8_8_8_REV, buffer);
        buffer.get(data);
        bufferedimage.setRGB(0, 0, width, height, data, 0, width);

        try {
            ImageIO.write(bufferedimage, "png", output);
            Log.info("Exported png to: {}", output.getAbsolutePath());
        } catch (IOException ioexception) {
            Log.info("Unable to write: ", ioexception);
        }
    }

    ProgressManager.pop(progressBar);
}

@SideOnly(Side.CLIENT)
private static void processRenderers() {
    log.info("Start processing " + modelList.size() + " models");
    ProgressBar bar = ProgressManager.push("Loading Renderers", modelList.size());
    for (Entry<Item, Entry<ModelResourceLocation, Integer>> e : modelList) {
        addRenderToRegistry(e.getKey(), e.getValue().getValue(), e.getValue().getKey(), bar);
    }
    log.info("Loaded " + modelList.size() + " models.");
    modelList.clear();
    ProgressManager.pop(bar);
}

/**
 * Initializes the operations
 */
void init() {
    isInitialized = true;
    ProgressManager.ProgressBar setProgress = ProgressManager.push("Initializing", operations.size());
    Side curSide = FMLCommonHandler.instance().getEffectiveSide();

    for(IOperation op : operations) {
        setProgress.step(op.toString());

        // If we're not supposed to run here...
        if((curSide == Side.CLIENT && !op.isClientOperation())
                || (curSide == Side.SERVER && !op.isServerOperation())) continue;

        try {
            op.runInit();
        } catch (Exception ex) {
            LogHelper.error("Error initializing operation.", ex);
        }
    }

    ProgressManager.pop(setProgress);

    // So we're only sorting it once...
    try {
        Collections.sort(operations);
    } catch(Exception e) {
        LogHelper.error("Error sorting operations in set {}; please report this error.", setName, e);
    }
}

void apply() {
    ProgressManager.ProgressBar setProgress = ProgressManager.push("Applying", operations.size());
    Side curSide = FMLCommonHandler.instance().getEffectiveSide();

    for(IOperation op : operations) {
        setProgress.step(op.toString());

        // If we're not supposed to run here...
        if((curSide == Side.CLIENT && !op.isClientOperation())
                || (curSide == Side.SERVER && !op.isServerOperation())
                || !op.shouldApply()) continue;

        try {
            op.runApply();
        }
        catch(Exception ex) {
            LogHelper.error("Error applying operation.", ex);
        }
    }

    // Remove any operations now...
    if(0 < getRemovedSets().length) {
        CraftingHarmonicsMod.undoSets(getRemovedSets());
    }

    if(0 < getDuration()) {
        SetManager.setWithDurationApplied(setName, getDuration());
    }

    ProgressManager.pop(setProgress);
}

private static void loadModSubsets() {
    ProgressBar bar = ProgressManager.push("Mod Subsets", ForgeRegistries.ITEMS.getKeys().size());
    HashMap<String, ItemStackSet> modSubsets = new HashMap<>();

    for (Item item : ForgeRegistries.ITEMS) {
        ResourceLocation ident = item.getRegistryName();
        bar.step(ident.toString());
        if (ident == null) {
            LogHelper.error("Failed to find identifier for: " + item);
            continue;
        }
        String modId = ident.getResourceDomain();
        ItemInfo.itemOwners.put(item, modId);
        ItemStackSet itemset = modSubsets.computeIfAbsent(modId, k -> new ItemStackSet());
        itemset.with(item);
    }
    ProgressManager.pop(bar);

    API.addSubset("Mod.Minecraft", modSubsets.remove("minecraft"));
    for (Entry<String, ItemStackSet> entry : modSubsets.entrySet()) {
        ModContainer mc = FMLCommonHandler.instance().findContainerFor(entry.getKey());
        if (mc == null) {
            LogHelper.error("Missing container for " + entry.getKey());
        } else {
            API.addSubset("Mod." + mc.getName(), entry.getValue());
        }
    }
}

public void loadRagdolls() {
    SekCPhysics.logger.debug("Loading ragdolls and checking for supported mods");
    List<ModContainer> modlist = Loader.instance().getActiveModList();
    ProgressManager.ProgressBar bar = ProgressManager.push("SekCPhysics", modlist.size());
    for(ModContainer mod : modlist) {
        bar.step("Processing " + mod.getModId());
        this.generateRagdollsFrom(mod.getModId());
    }
    ProgressManager.pop(bar);
}

@Override
public IRegistry<ModelResourceLocation, IBakedModel> setupModelRegistry()
{
    isLoading = true;
    loadBlocks();
    loadVariantItemModels();
    missingModel = ModelLoaderRegistry.getMissingModel();
    stateModels.put(MODEL_MISSING, missingModel);

    final Set<ResourceLocation> textures = Sets.newHashSet(ModelLoaderRegistry.getTextures());
    textures.remove(TextureMap.LOCATION_MISSING_TEXTURE);
    textures.addAll(LOCATIONS_BUILTIN_TEXTURES);

    textureMap.loadSprites(resourceManager, new ITextureMapPopulator()
    {
        public void registerSprites(TextureMap map)
        {
            for(ResourceLocation t : textures)
            {
                map.registerSprite(t);
            }
        }
    });

    IBakedModel missingBaked = missingModel.bake(missingModel.getDefaultState(), DefaultVertexFormats.ITEM, DefaultTextureGetter.INSTANCE);
    Map<IModel, IBakedModel> bakedModels = Maps.newHashMap();
    HashMultimap<IModel, ModelResourceLocation> models = HashMultimap.create();
    Multimaps.invertFrom(Multimaps.forMap(stateModels), models);

    if (firstLoad)
    {
        firstLoad = false;
        for (ModelResourceLocation mrl : stateModels.keySet())
        {
            bakedRegistry.putObject(mrl, missingBaked);
        }
        return bakedRegistry;
    }

    ProgressBar bakeBar = ProgressManager.push("ModelLoader: baking", models.keySet().size());

    for(IModel model : models.keySet())
    {
        bakeBar.step("[" + Joiner.on(", ").join(models.get(model)) + "]");
        if(model == getMissingModel())
        {
            bakedModels.put(model, missingBaked);
        }
        else
        {
            bakedModels.put(model, model.bake(model.getDefaultState(), DefaultVertexFormats.ITEM, DefaultTextureGetter.INSTANCE));
        }
    }

    ProgressManager.pop(bakeBar);

    for (Entry<ModelResourceLocation, IModel> e : stateModels.entrySet())
    {
        bakedRegistry.putObject(e.getKey(), bakedModels.get(e.getValue()));
    }
    return bakedRegistry;
}

public Map<DynamicMachine, List<MachineRecipe>> loadRecipes(@Nullable EntityPlayer player) {
    ProgressManager.ProgressBar barRecipes = ProgressManager.push("RecipeRegistry", 3);
    barRecipes.step("Discovering Files");
    DataLoadProfiler profiler = new DataLoadProfiler();

    boolean frozen = MachineRecipe.isFrozen();
    if(frozen) {
        MachineRecipe.unfreeze();
    }

    Map<RecipeLoader.FileType, List<File>> potentialRecipes = RecipeLoader.discoverDirectory(CommonProxy.dataHolder.getRecipeDirectory());
    barRecipes.step("Loading Recipes");
    List<MachineRecipe> recipes = RecipeLoader.loadRecipes(potentialRecipes, earlyRecipes);
    DataLoadProfiler.StatusLine sl = profiler.createLine("Load-Phase: ");
    DataLoadProfiler.Status success = sl.appendStatus("%s loaded");
    DataLoadProfiler.Status failed = sl.appendStatus("%s failed");

    success.setCounter(recipes.size());

    Map<String, Exception> failures = RecipeLoader.captureFailedAttempts();
    failed.setCounter(failures.size());
    if(failures.size() > 0) {
        ModularMachinery.log.warn("Encountered " + failures.size() + " problems while loading recipe!");
        for (String fileName : failures.keySet()) {
            ModularMachinery.log.warn("Couldn't load recipe from file " + fileName);
            failures.get(fileName).printStackTrace();
        }
    }

    Map<DynamicMachine, List<MachineRecipe>> out = new HashMap<>();
    DataLoadProfiler.StatusLine unknown = profiler.createLine("");
    DataLoadProfiler.Status unknownCounter = unknown.appendStatus("Unknown Machinery: %s");

    Map<DynamicMachine, Tuple<DataLoadProfiler.Status, DataLoadProfiler.Status>> statusMap = new HashMap<>();
    Map<ResourceLocation, MachineRecipe> tempRegistry = new HashMap<>();
    barRecipes.step("Validation");
    for (MachineRecipe mr : recipes) {
        DynamicMachine m = mr.getOwningMachine();
        if(m == null) {
            unknownCounter.incrementCounter();
            ModularMachinery.log.warn("MachineRecipe loaded for unknown machine: " + mr.getOwningMachineIdentifier() + " - responsible file: " + mr.getRecipeFilePath());
            continue;
        }
        Tuple<DataLoadProfiler.Status, DataLoadProfiler.Status> status = statusMap.get(m);
        if(status == null) {
            DataLoadProfiler.StatusLine line = profiler.createLine(m.getLocalizedName() + " (Recipes): ");
            status = new Tuple<>(line.appendStatus("%s loaded"), line.appendStatus("%s failed"));
            statusMap.put(m, status);
        }

        DataLoadProfiler.Status loaded = status.getFirst();
        DataLoadProfiler.Status fail = status.getSecond();

        if(tempRegistry.containsKey(mr.getRegistryName())) {
            MachineRecipe other = tempRegistry.get(mr.getRegistryName());
            if(other != null) {
                ModularMachinery.log.warn("MachineRecipe with registryName " + mr.getRegistryName() + " already exists!");
                ModularMachinery.log.warn("Offending files: '" + mr.getRecipeFilePath() + "' and '" + other.getRecipeFilePath() + "' !");
                fail.incrementCounter();
                continue;
            }
        }
        loaded.incrementCounter();
        tempRegistry.put(mr.getRegistryName(), mr);
        List<MachineRecipe> recipeList = out.computeIfAbsent(mr.getOwningMachine(), r -> Lists.newArrayList());
        recipeList.add(mr);
    }
    profiler.printLines(player);
    ProgressManager.pop(barRecipes);
    if(frozen) {
        MachineRecipe.freezeChanges();
    }
    return out;
}

public void saveModStats(String name, TextureMap map, File outputFolder) {
    Map<String, Long> modPixelCounts = map.mapUploadedSprites.values().stream()
            .collect(Collectors.groupingBy(
                    sprite -> new ResourceLocation(sprite.getIconName()).getResourceDomain(),
                    Collectors.summingLong(sprite -> sprite.getIconWidth() * sprite.getIconHeight()))
            );

    final long totalPixels = modPixelCounts.values().stream().mapToLong(longValue -> longValue).sum();

    final String filename = name + "_mod_statistics";
    File output = new File(outputFolder, filename + ".js");

    List<Map.Entry<String, Long>> sortedEntries = modPixelCounts.entrySet().stream()
            .sorted(Collections.reverseOrder(Comparator.comparing(Map.Entry::getValue)))
            .collect(Collectors.toList());

    ProgressManager.ProgressBar progressBar = ProgressManager.push("Dumping Mod TextureMap Statistics", sortedEntries.size());

    try {
        FileWriter fileWriter = new FileWriter(output);
        fileWriter.write("var modStatistics = \n//Start of Data\n");
        JsonWriter jsonWriter = new JsonWriter(fileWriter);
        jsonWriter.setIndent("    ");
        jsonWriter.beginArray();
        {
            for (Map.Entry<String, Long> modPixels : sortedEntries) {
                String resourceDomain = modPixels.getKey();
                progressBar.step(resourceDomain);

                long pixelCount = modPixels.getValue();
                ModMetadata metadata = getModMetadata(resourceDomain);

                jsonWriter.beginObject()
                        .name("resourceDomain").value(resourceDomain)
                        .name("pixelCount").value(pixelCount)
                        .name("percentOfTextureMap").value(pixelCount * 100f / totalPixels)
                        .name("modName").value(metadata.name)
                        .name("url").value(metadata.url);

                jsonWriter.name("authors").beginArray();
                for (String author : metadata.authorList) {
                    jsonWriter.value(author);
                }
                jsonWriter.endArray();

                jsonWriter.endObject();
            }

        }
        jsonWriter.endArray();
        jsonWriter.close();
        fileWriter.close();

        Log.info("Saved mod statistics to {}.", output.getAbsoluteFile());
    } catch (IOException e) {
        Log.error("Failed to save mod statistics info.", e);
    }

    ProgressManager.pop(progressBar);
}