path: root/src/main/java/io/github/moulberry/notenoughupdates/miscfeatures/CustomSkulls.java

package io.github.moulberry.notenoughupdates.miscfeatures;

import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.mojang.authlib.GameProfile;
import io.github.moulberry.notenoughupdates.NotEnoughUpdates;
import net.minecraft.client.Minecraft;
import net.minecraft.client.model.ModelHumanoidHead;
import net.minecraft.client.model.ModelSkeletonHead;
import net.minecraft.client.renderer.GlStateManager;
import net.minecraft.client.renderer.Tessellator;
import net.minecraft.client.renderer.WorldRenderer;
import net.minecraft.client.renderer.block.model.*;
import net.minecraft.client.renderer.texture.*;
import net.minecraft.client.renderer.vertex.DefaultVertexFormats;
import net.minecraft.client.resources.IResourceManager;
import net.minecraft.client.resources.IResourceManagerReloadListener;
import net.minecraft.client.resources.model.IBakedModel;
import net.minecraft.client.resources.model.ModelRotation;
import net.minecraft.client.resources.model.SimpleBakedModel;
import net.minecraft.util.EnumFacing;
import net.minecraft.util.ResourceLocation;

import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;
import java.util.*;

public class CustomSkulls implements IResourceManagerReloadListener {
	private static final CustomSkulls INSTANCE = new CustomSkulls();

	public static CustomSkulls getInstance() {
		return INSTANCE;
	}

	private final ResourceLocation atlas = new ResourceLocation("notenoughupdates:custom_skull_textures_atlas");
	private final ResourceLocation configuration = new ResourceLocation(
		"notenoughupdates:custom_skull_textures/customskull.json");
	protected final TextureMap textureMap = new TextureMap("custom_skull_textures");

	public static ItemCameraTransforms.TransformType mostRecentTransformType = ItemCameraTransforms.TransformType.NONE;

	protected final Map<ResourceLocation, TextureAtlasSprite> sprites = Maps.newHashMap();

	private final FaceBakery faceBakery = new FaceBakery();
	private final ModelSkeletonHead humanoidHead = new ModelHumanoidHead();

	private final HashMap<String, CustomSkull> customSkulls = new HashMap<>();

	private final Gson gson = new GsonBuilder().create();

	private static class CustomSkull {
		private ModelBlock model;
		private IBakedModel modelBaked;

		private ResourceLocation texture;
	}

	@Override
	public void onResourceManagerReload(IResourceManager resourceManager) {
		customSkulls.clear();

		try (
			BufferedReader reader = new BufferedReader(new InputStreamReader(
				Minecraft.getMinecraft().getResourceManager().getResource(configuration).getInputStream(),
				StandardCharsets.UTF_8
			))
		) {
			JsonObject json = gson.fromJson(reader, JsonObject.class);

			if (json == null) return;

			for (Map.Entry<String, JsonElement> entry : json.entrySet()) {
				if (entry.getValue().isJsonObject()) {
					JsonObject obj = entry.getValue().getAsJsonObject();
					if (obj.has("model")) {
						String location = obj.get("model").getAsString();
						ResourceLocation loc = new ResourceLocation("notenoughupdates:custom_skull_textures/" + location + ".json");

						CustomSkull skull = new CustomSkull();
						skull.model = ModelBlock.deserialize(new InputStreamReader(Minecraft
							.getMinecraft()
							.getResourceManager()
							.getResource(loc)
							.getInputStream()));

						customSkulls.put(entry.getKey(), skull);
					} else if (obj.has("texture")) {
						String location = obj.get("texture").getAsString();
						ResourceLocation loc = new ResourceLocation("notenoughupdates:custom_skull_textures/" + location + ".png");

						CustomSkull skull = new CustomSkull();
						skull.texture = loc;

						Minecraft.getMinecraft().getTextureManager().deleteTexture(skull.texture);

						customSkulls.put(entry.getKey(), skull);
					}
				}
			}

			loadSprites();

			for (CustomSkull skull : customSkulls.values()) {
				if (skull.model != null) {
					skull.modelBaked = bakeModel(skull.model, ModelRotation.X0_Y0, false);
				}
			}

			Minecraft.getMinecraft().getTextureManager().loadTexture(atlas, textureMap);
		} catch (Exception ignored) {
		}
	}

	private void loadSprites() {
		final Set<ResourceLocation> set = this.getAllTextureLocations();
		set.remove(TextureMap.LOCATION_MISSING_TEXTURE);
		IIconCreator iiconcreator = iconRegistry -> {
			for (ResourceLocation resourcelocation : set) {
				TextureAtlasSprite textureatlassprite = iconRegistry.registerSprite(resourcelocation);
				CustomSkulls.this.sprites.put(resourcelocation, textureatlassprite);
			}
		};
		this.textureMap.loadSprites(Minecraft.getMinecraft().getResourceManager(), iiconcreator);
		this.sprites.put(new ResourceLocation("missingno"), this.textureMap.getMissingSprite());
	}

	protected Set<ResourceLocation> getAllTextureLocations() {
		Set<ResourceLocation> set = new HashSet<>();

		for (CustomSkull skull : customSkulls.values()) {
			if (skull.model != null) {
				set.addAll(getTextureLocations(skull.model));
			}
		}

		return set;
	}

	protected Set<ResourceLocation> getTextureLocations(ModelBlock modelBlock) {
		Set<ResourceLocation> set = Sets.newHashSet();

		for (BlockPart blockpart : modelBlock.getElements()) {
			for (BlockPartFace blockpartface : blockpart.mapFaces.values()) {
				ResourceLocation resourcelocation = new ResourceLocation(
					"notenoughupdates",
					modelBlock.resolveTextureName(blockpartface.texture)
				);
				set.add(resourcelocation);
			}
		}

		set.add(new ResourceLocation("notenoughupdates", modelBlock.resolveTextureName("particle")));
		return set;
	}

	protected IBakedModel bakeModel(
		ModelBlock modelBlockIn,
		net.minecraftforge.client.model.ITransformation modelRotationIn,
		boolean uvLocked
	) {
		TextureAtlasSprite textureatlassprite = this.sprites.get(new ResourceLocation(
			"notenoughupdates",
			modelBlockIn.resolveTextureName("particle")
		));
		SimpleBakedModel.Builder simplebakedmodel$builder = (new SimpleBakedModel.Builder(modelBlockIn)).setTexture(
			textureatlassprite);

		for (BlockPart blockpart : modelBlockIn.getElements()) {
			for (EnumFacing enumfacing : blockpart.mapFaces.keySet()) {
				BlockPartFace blockpartface = blockpart.mapFaces.get(enumfacing);
				TextureAtlasSprite textureatlassprite1 = this.sprites.get(new ResourceLocation(
					"notenoughupdates",
					modelBlockIn.resolveTextureName(blockpartface.texture)
				));

				if (blockpartface.cullFace == null || !net.minecraftforge.client.model.TRSRTransformation.isInteger(
					modelRotationIn.getMatrix())) {
					simplebakedmodel$builder.addGeneralQuad(this.makeBakedQuad(
						blockpart,
						blockpartface,
						textureatlassprite1,
						enumfacing,
						modelRotationIn,
						uvLocked
					));
				} else {
					simplebakedmodel$builder.addFaceQuad(
						modelRotationIn.rotate(blockpartface.cullFace),
						this.makeBakedQuad(blockpart, blockpartface, textureatlassprite1, enumfacing, modelRotationIn, uvLocked)
					);
				}
			}
		}

		return simplebakedmodel$builder.makeBakedModel();
	}

	private BakedQuad makeBakedQuad(
		BlockPart p_177589_1_,
		BlockPartFace p_177589_2_,
		TextureAtlasSprite p_177589_3_,
		EnumFacing p_177589_4_,
		ModelRotation p_177589_5_,
		boolean p_177589_6_
	) {
		return makeBakedQuad(
			p_177589_1_,
			p_177589_2_,
			p_177589_3_,
			p_177589_4_,
			(net.minecraftforge.client.model.ITransformation) p_177589_5_,
			p_177589_6_
		);
	}

	protected BakedQuad makeBakedQuad(
		BlockPart p_177589_1_,
		BlockPartFace p_177589_2_,
		TextureAtlasSprite p_177589_3_,
		EnumFacing p_177589_4_,
		net.minecraftforge.client.model.ITransformation p_177589_5_