Java tutorial
/* * Minecraft Forge * Copyright (c) 2016-2019. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation version 2.1 * of the License. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ package net.minecraftforge.client.model; import java.util.HashSet; import java.util.Map; import java.util.Set; import net.minecraft.client.Minecraft; import net.minecraft.client.renderer.color.BlockColors; import net.minecraft.client.renderer.model.*; import net.minecraft.client.renderer.texture.MissingTextureSprite; import net.minecraft.client.renderer.texture.TextureAtlasSprite; import net.minecraft.client.renderer.texture.AtlasTexture; import net.minecraft.profiler.IProfiler; import net.minecraft.resources.IResourceManager; import net.minecraft.util.ResourceLocation; import net.minecraftforge.logging.ModelLoaderErrorMessage; import java.util.function.Function; import com.google.common.collect.Maps; import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; import javax.annotation.Nullable; import static net.minecraftforge.fml.Logging.MODELLOADING; public final class ModelLoader extends ModelBakery { private static final Logger LOGGER = LogManager.getLogger(); private final Map<ResourceLocation, Exception> loadingExceptions = Maps.newHashMap(); private IUnbakedModel missingModel = null; private boolean isLoading = false; private static ModelLoader instance; @Nullable public static ModelLoader instance() { return instance; } public boolean isLoading() { return isLoading; } public ModelLoader(IResourceManager manager, BlockColors colours, IProfiler profiler, int p_i226056_4_) { super(manager, colours, false); instance = this; processLoading(profiler, p_i226056_4_); } private static Set<ResourceLocation> specialModels = new HashSet<>(); /** * Indicate to vanilla that it should load and bake the given model, even if no blocks or * items use it. This is useful if e.g. you have baked models only for entity renderers. * Call during {@link net.minecraftforge.client.event.ModelRegistryEvent} * @param rl The model, either {@link ModelResourceLocation} to point to a blockstate variant, * or plain {@link ResourceLocation} to point directly to a json in the models folder. */ public static void addSpecialModel(ResourceLocation rl) { specialModels.add(rl); } @Override public Set<ResourceLocation> getSpecialModels() { return specialModels; } /** * Hooked from ModelBakery, allows using MRLs that don't end with "inventory" for items. */ public static ModelResourceLocation getInventoryVariant(String s) { if (s.contains("#")) { return new ModelResourceLocation(s); } return new ModelResourceLocation(s, "inventory"); } protected ResourceLocation getModelLocation(ResourceLocation model) { return new ResourceLocation(model.getNamespace(), model.getPath() + ".json"); } protected IUnbakedModel getMissingModel() { if (missingModel == null) { try { missingModel = getUnbakedModel(MODEL_MISSING); } catch (Exception e) { throw new RuntimeException("Missing the missing model, this should never happen"); } } return missingModel; } /** * Use this if you don't care about the exception and want some model anyway. */ public IUnbakedModel getModelOrMissing(ResourceLocation location) { try { return getUnbakedModel(location); } catch (Exception e) { return getMissingModel(); } } /** * Use this if you want the model, but need to log the error. */ public IUnbakedModel getModelOrLogError(ResourceLocation location, String error) { try { return getUnbakedModel(location); } catch (Exception e) { LOGGER.error(error, e); return getMissingModel(); } } // Temporary to compile things public static final class White { public static final ResourceLocation LOCATION = new ResourceLocation("white"); private static TextureAtlasSprite instance = null; public static final TextureAtlasSprite instance() { if (instance == null) { instance = new Material(AtlasTexture.LOCATION_BLOCKS_TEXTURE, LOCATION).func_229314_c_(); } return instance; } } /** * 16x16 pure white sprite. */ /*/ TODO Custom TAS public static final class White extends TextureAtlasSprite { public static final ResourceLocation LOCATION = new ResourceLocation("white"); public static final White INSTANCE = new White(); private White() { super(LOCATION.toString()); this.width = this.height = 16; } @Override public boolean hasCustomLoader(IResourceManager manager, ResourceLocation location) { return true; } @Override public boolean load(IResourceManager manager, ResourceLocation location, Function<ResourceLocation, TextureAtlasSprite> textureGetter) { BufferedImage image = new BufferedImage(this.getIconWidth(), this.getIconHeight(), BufferedImage.TYPE_INT_ARGB); Graphics2D graphics = image.createGraphics(); graphics.setBackground(Color.WHITE); graphics.clearRect(0, 0, this.getIconWidth(), this.getIconHeight()); int[][] pixels = new int[Minecraft.getMinecraft().gameSettings.mipmapLevels + 1][]; pixels[0] = new int[image.getWidth() * image.getHeight()]; image.getRGB(0, 0, image.getWidth(), image.getHeight(), pixels[0], 0, image.getWidth()); this.clearFramesTextureData(); this.framesTextureData.add(pixels); return false; } public void register(TextureMap map) { map.setTextureEntry(White.INSTANCE); } } */ @SuppressWarnings("serial") public static class ItemLoadingException extends ModelLoadingException { private final Exception normalException; private final Exception blockstateException; public ItemLoadingException(String message, Exception normalException, Exception blockstateException) { super(message); this.normalException = normalException; this.blockstateException = blockstateException; } } /** * Internal, do not use. */ public void onPostBakeEvent(Map<ResourceLocation, IBakedModel> modelRegistry) { IBakedModel missingModel = modelRegistry.get(MODEL_MISSING); for (Map.Entry<ResourceLocation, Exception> entry : loadingExceptions.entrySet()) { // ignoring pure ResourceLocation arguments, all things we care about pass ModelResourceLocation if (entry.getKey() instanceof ModelResourceLocation) { LOGGER.debug(MODELLOADING, () -> new ModelLoaderErrorMessage((ModelResourceLocation) entry.getKey(), entry.getValue())); final ModelResourceLocation location = (ModelResourceLocation) entry.getKey(); final IBakedModel model = modelRegistry.get(location); if (model == null) { modelRegistry.put(location, missingModel); } } } loadingExceptions.clear(); isLoading = false; } /** * Helper method for registering all itemstacks for given item to map to universal bucket model. *//* public static void setBucketModelDefinition(Item item) { ModelLoader.setCustomMeshDefinition(item, stack -> ModelDynBucket.LOCATION); ModelBakery.registerItemVariants(item, ModelDynBucket.LOCATION); } */ private static final Function<ResourceLocation, IUnbakedModel> DEFAULT_MODEL_GETTER = (rl) -> ModelLoader .instance().getModelOrMissing(rl); /** * Get the default texture getter the models will be baked with. */ public static Function<Material, TextureAtlasSprite> defaultTextureGetter() { return Material::func_229314_c_; } public static Function<ResourceLocation, IUnbakedModel> defaultModelGetter() { return DEFAULT_MODEL_GETTER; } }