private IBakedModel getBaseModel( IModelState state, VertexFormat format, Function<ResourceLocation, TextureAtlasSprite> bakedTextureGetter ) { // Load the base model try { return ModelLoaderRegistry.getModel( MODEL_BASE ).bake( state, format, bakedTextureGetter ); } catch( Exception e ) { throw new RuntimeException( e ); } }
@Override public IBakedModel bake(IModelState state, VertexFormat format, Function<ResourceLocation, TextureAtlasSprite> bakedTextureGetter) { return ModelLoaderRegistry.getMissingModel().bake(ModelLoaderRegistry.getMissingModel().getDefaultState(), format, bakedTextureGetter); }
private static IBakedModel getTexturedModel(IBakedModel original, ResourceLocation location, Fluid fluid) { try { IModel model = ModelLoaderRegistry.getModel(location); IModel retextured = model.retexture(ImmutableMap.of("fluid", fluid.getStill().toString())); return retextured.bake(retextured.getDefaultState(), DefaultVertexFormats.ITEM, ModelLoader.defaultTextureGetter()); } catch(Exception e) { e.printStackTrace(); return original; } }
@SideOnly(Side.CLIENT) private IBakedModel paintModel(IModel sourceModel, final @Nullable IBlockState paintSource, IModelState rotation, final PaintMode paintMode) { IModelState state = sourceModel.getDefaultState(); state = combine(state, rotation); if (state instanceof UVLock) { sourceModel = sourceModel.uvlock(true); state = ((UVLock) state).getParent(); } if (state == null) { state = sourceModel.getDefaultState(); } final TextureAtlasSprite missingSprite = Minecraft.getMinecraft().getTextureMapBlocks().getMissingSprite(); final TextureAtlasSprite paintSprite = paintSource == null ? missingSprite : NullHelper.first(Minecraft.getMinecraft().getBlockRendererDispatcher().getBlockModelShapes().getTexture(paintSource), missingSprite); if (paintMode == PaintMode.ALL_TEXTURES) { return sourceModel.bake(state, Attributes.DEFAULT_BAKED_FORMAT, new AllPainter(paintSprite)); } else { return sourceModel.bake(state, Attributes.DEFAULT_BAKED_FORMAT, new TaggedPainter(paintSprite)); } }
protected IBakedModel handleDisplayStandType(ItemStack displayStandType, boolean axisX, EnumFacing facing) { if (displayStandType != null && !displayStandType.isEmpty()) { // Get reference texture IBlockState blockState = BlockHelpers.getBlockStateFromItemStack(displayStandType); String textureName = Minecraft.getMinecraft().getBlockRendererDispatcher() .getBlockModelShapes().getTexture(blockState).getIconName(); // Retexture our model String cacheName = textureName + axisX + facing.toString(); IBakedModel bakedRetexturedModel = retexturedCache.get(cacheName); if (bakedRetexturedModel == null) { IModel retexturedModel = retexturableModel.retexture(ImmutableMap.of("base", textureName)); IModelState modelState = ROTATIONS.get(facing); // Hack, see DisplayStand#bakeVariantModel, should just be retexturableModel.getDefaultState(); bakedRetexturedModel = retexturedModel.bake(modelState, DefaultVertexFormats.BLOCK, org.cyclops.cyclopscore.helper.RenderHelpers.TEXTURE_GETTER); retexturedCache.put(cacheName, bakedRetexturedModel); } return bakedRetexturedModel; } return untexturedBakedModel; }
@Override public IModelState getDefaultState() { return this.parent.getDefaultState(); }
public WeightedRandomModel(VariantList variants) throws Exception { this.variants = variants.getVariantList(); locations = new ArrayList<>(); textures = Sets.newHashSet(); models = new ArrayList<>(); ImmutableList.Builder<Pair<IModel, IModelState>> builder = ImmutableList.builder(); for (Variant variant : this.variants) { ResourceLocation location = variant.getModelLocation(); locations.add(location); IModel model = variant.process(ModelLoaderRegistry.getModel(location)); textures.addAll(model.getTextures()); models.add(model); IModelState modelDefaultState = model.getDefaultState(); Preconditions.checkNotNull(modelDefaultState, "Model %s returned null as default state", location); builder.add(Pair.of(model, new ModelStateComposition(variant.getState(), modelDefaultState))); } // If all variants are missing, add one with the missing model and default rotation if (models.size() == 0) { IModel missing = ModelLoaderRegistry.getMissingModel(); models.add(missing); builder.add(Pair.of(missing, TRSRTransformation.identity())); } defaultState = new MultiModelState(builder.build()); }
@Override public WeightedRandomModel retexture(ImmutableMap<String, String> textures) { if (textures.isEmpty()) return this; // Rebuild the texture list taking into account new textures Set<ResourceLocation> modelTextures = Sets.newHashSet(); // Recreate the MultiModelState so that the IModelState data is properly applied to the retextured model ImmutableList.Builder<Pair<IModel, IModelState>> builder = ImmutableList.builder(); List<IModel> retexturedModels = Lists.newArrayList(); for (int i = 0; i < variants.size(); i++) { IModel retextured = models.get(i).retexture(textures); modelTextures.addAll(retextured.getTextures()); retexturedModels.add(retextured); builder.add(Pair.of(retextured, variants.get(i).getState())); } return new WeightedRandomModel(variants, locations, modelTextures, retexturedModels, new MultiModelState(builder.build())); } }
private IModel retextureModel(IModel overrideModel, ResourceLocation texture) { final ImmutableMap.Builder<String, String> textures = ImmutableMap.builder(); for (String t : texturesToReplace) textures.put(t, texture.toString()); return overrideModel.retexture(textures.build()); }
for (ResourceLocation location : model.getDependencies()) { ModelLoaderRegistry.getModelOrMissing(location); model = model.retexture(textures);
@Override public Collection<ResourceLocation> getTextures() { return this.parent.getTextures(); }
for (ResourceLocation location : model.getDependencies()) { ModelLoaderRegistry.getModelOrMissing(location); texturesBuilder.addAll(model.getTextures());
private IBakedModel bakeModel(IAlleleButterflySpecies species, float size) { ImmutableMap<String, String> textures = ImmutableMap.of("butterfly", species.getItemTexture()); if (modelButterfly == null) { try { modelButterfly = ModelLoaderRegistry.getModel(new ResourceLocation(Constants.MOD_ID, "item/butterfly_ge")); } catch (Exception e) { throw new RuntimeException(e); } } IModel model = modelButterfly.retexture(textures); IBakedModel bakedModel = model.bake(ModelRotation.X0_Y0, DefaultVertexFormats.ITEM, DefaultTextureGetter.INSTANCE); float scale = 1F / 16F; IModelState state = ModelUtil.loadModelState(new ResourceLocation(Constants.MOD_ID, "models/item/butterfly_ge")); state = new ModelStateComposition(state, new SimpleModelState(getTransformations(size))); return new PerspectiveMapWrapper(new TRSRBakedModel(bakedModel, -0.03125F, 0.25F - size * 0.37F, -0.03125F + size * scale, size * 1.4F), state); }
@Override public IModelState getDefaultState() { return this.getBaseModel().getDefaultState(); } }
@Override public IModel retexture(ImmutableMap<String, String> textures) { if (textures.isEmpty()) return this; ImmutableMap.Builder<Selector, IModel> builder = ImmutableMap.builder(); for (Map.Entry<Selector, IModel> partModel : partModels.entrySet()) { builder.put(partModel.getKey(), partModel.getValue().retexture(textures)); } return new MultipartModel(location, multipart, builder.build()); } }
public static boolean belongsToToolPart(ResourceLocation location) { for(IToolPart toolpart : TinkerRegistry.getToolParts()) { if(!(toolpart instanceof Item)) { continue; // WHY?! } try { Optional<ResourceLocation> storedResourceLocation = MaterialModelLoader.getToolPartModelLocation(toolpart); if(storedResourceLocation.isPresent()) { ResourceLocation stored = storedResourceLocation.get(); ResourceLocation modelLocation = new ResourceLocation(stored.getResourceDomain(), "item/" + stored.getResourcePath()); IModel partModel = ModelLoaderRegistry.getModel(modelLocation); // the actual texture of the part ResourceLocation baseTexture = partModel.getTextures().iterator().next(); if(baseTexture.toString().equals(location.toString())) { return true; } } } catch(Exception e) { return false; } } return false; }
private IBakedModel getBaseModel( IModelState state, VertexFormat format, Function<ResourceLocation, TextureAtlasSprite> bakedTextureGetter ) { // Load the base model try { return ModelLoaderRegistry.getModel( MODEL_BASE ).bake( state, format, bakedTextureGetter ); } catch( Exception e ) { throw new RuntimeException( e ); } }
private IBakedModel getModel() { if (bakedModel == null) { return bakedModel = model.bake(model.getDefaultState(), DefaultVertexFormats.BLOCK, DefaultTextureGetter.INSTANCE); } return bakedModel; }
protected IBakedModel getActualModel(String texture, List<PropertyTableItem.TableItem> items, EnumFacing facing) { IBakedModel bakedModel = originalModel; if(texture != null) { if(cache.containsKey(texture)) { bakedModel = cache.get(texture); } else if(tableModel != null) { ImmutableMap.Builder<String, String> builder = ImmutableMap.builder(); builder.put("bottom", texture); builder.put("leg", texture); builder.put("legBottom", texture); IModel retexturedModel = tableModel.retexture(builder.build()); IModelState modelState = retexturedModel.getDefaultState(); bakedModel = retexturedModel.bake(modelState, format, textureGetter); cache.put(texture, bakedModel); } } final IBakedModel parentModel = bakedModel; try { bakedModel = tableItemCombinedCache.get(new TableItemCombinationCacheKey(items, bakedModel, facing), () -> getCombinedBakedModel(items, facing, parentModel)); } catch(ExecutionException e) { log.error(e); } return bakedModel; }
@Override public IModelState getDefaultState() { return this.getBaseModel().getDefaultState(); } }