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

@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);
}

@Subscribe
public void propogateStateMessage(FMLEvent stateEvent)
{
    if (stateEvent instanceof FMLPreInitializationEvent)
    {
        modObjectList = buildModObjectList();
    }
    ProgressBar bar = ProgressManager.push(stateEvent.description(), activeModList.size(), true);
    for (ModContainer mc : activeModList)
    {
        bar.step(mc.getName());
        sendEventToModContainer(stateEvent, mc);
    }
    ProgressManager.pop(bar);
}

@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);
}

@SideOnly(Side.CLIENT)
private static void addRenderToRegistry(Item item, int meta, ModelResourceLocation loc, ProgressBar bar) {
    String toString = loc.toString() + ":" + meta;
    bar.step(toString);
    ModelLoader.setCustomModelResourceLocation(item, meta, loc);
    // Minecraft.getMinecraft().getRenderItem().getItemModelMesher().register(item, meta, loc);
}

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());
        }
    }
}

@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 FMLProgressBar(ProgressBar progressBar) {
    this.progressBar = progressBar;
}