Remove: all vanilla editions

This commit is contained in:
ZekerZhayard committed 2023-01-29 22:52:21 +08:00
1 parent c2dad72690
commit 755f7647ed
136 files changed
+113 -1355

No files matched your search

@@ -0,0 +1,254 @@
package customskinloader;
import java.io.File;
import java.util.Map;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.function.Consumer;
import com.google.common.collect.Maps;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.mojang.authlib.GameProfile;
import com.mojang.authlib.minecraft.MinecraftProfileTexture;
import customskinloader.config.Config;
import customskinloader.config.SkinSiteProfile;
import customskinloader.loader.ProfileLoader;
import customskinloader.log.LogManager;
import customskinloader.log.Logger;
import customskinloader.profile.DynamicSkullManager;
import customskinloader.profile.ModelManager0;
import customskinloader.profile.ProfileCache;
import customskinloader.profile.UserProfile;
import customskinloader.utils.MinecraftUtil;
/**
* Custom skin loader mod for Minecraft.
*
* @author Jeremy Lam [JLChnToZ] 2013-2014 & Alexander Xia [xfl03] 2014-2023
* @version @MOD_FULL_VERSION@
*/
public class CustomSkinLoader {
public static final String CustomSkinLoader_VERSION = "@MOD_VERSION@";
public static final String CustomSkinLoader_FULL_VERSION = "@MOD_FULL_VERSION@";
public static final int CustomSkinLoader_BUILD_NUMBER = Integer.parseInt("@MOD_BUILD_NUMBER@");
public static final File
DATA_DIR = new File(MinecraftUtil.getMinecraftDataDir(), "CustomSkinLoader"),
LOG_FILE = new File(DATA_DIR, "CustomSkinLoader.log"),
CONFIG_FILE = new File(DATA_DIR, "CustomSkinLoader.json");
public static final Gson GSON = new GsonBuilder().setPrettyPrinting().create();
public static final Logger logger = initLogger();
public static final Config config = initConfig();
private static final ProfileCache profileCache = new ProfileCache();
private static final DynamicSkullManager dynamicSkullManager = new DynamicSkullManager();
private static final ExecutorService THREAD_POOL = new ThreadPoolExecutor(
config.threadPoolSize, config.threadPoolSize, 1L, TimeUnit.MINUTES, new LinkedBlockingQueue<>());
//Correct thread name in thread pool
private static final ThreadFactory defaultFactory = Executors.defaultThreadFactory();
private static final ThreadFactory customFactory = r -> {
Thread t = defaultFactory.newThread(r);
if (r instanceof Thread) {
t.setName(((Thread) r).getName());
}
return t;
};
//Thread pool will discard oldest task when queue reaches 333 tasks
private static final ThreadPoolExecutor threadPool = new ThreadPoolExecutor(
config.threadPoolSize, config.threadPoolSize, 1L, TimeUnit.MINUTES,
new LinkedBlockingQueue<>(333), customFactory, new ThreadPoolExecutor.DiscardOldestPolicy()
);
public static void loadProfileTextures(Runnable runnable) {
THREAD_POOL.execute(runnable);
}
public static void loadProfileLazily(
GameProfile gameProfile, Consumer<Map<MinecraftProfileTexture.Type, MinecraftProfileTexture>> consumer) {
String username = gameProfile.getName();
String credential = MinecraftUtil.getCredential(gameProfile);
// Fix: http://hopper.minecraft.net/crashes/minecraft/MCX-2773713
if (username == null) {
logger.warning("Could not load profile: username is null.");
consumer.accept(Maps.newHashMap());
return;
}
String tempName = Thread.currentThread().getName();
Thread.currentThread().setName(username); // Change Thread Name
if (profileCache.isLoading(credential)) {
profileCache.putLoader(credential, consumer);
Thread.currentThread().setName(tempName);
return;
}
consumer.accept(loadProfile(gameProfile));
Thread.currentThread().setName(tempName);
profileCache.getLastLoader(credential).ifPresent(c -> loadProfileLazily(gameProfile, c));
}
//For User Skin
public static Map<MinecraftProfileTexture.Type, MinecraftProfileTexture> loadProfile(GameProfile gameProfile) {
String credential = MinecraftUtil.getCredential(gameProfile);
UserProfile profile;
if (profileCache.isReady(credential)) {
logger.info("Cached profile will be used.");
profile = profileCache.getProfile(credential);
if (profile == null) {
logger.warning("(Cached Profile is empty!) Expiry: " + profileCache.getExpiry(credential));
if (profileCache.isExpired(credential)) { // force load
profile = loadProfile0(gameProfile, false);
}
} else {
logger.info(profile.toString(profileCache.getExpiry(credential)));
}
} else {
profileCache.setLoading(credential, true);
profile = loadProfile0(gameProfile, false);
}
return ModelManager0.fromUserProfile(profile);
}
//Core
public static UserProfile loadProfile0(GameProfile gameProfile, boolean isSkull) {
String username = gameProfile.getName();
String credential = MinecraftUtil.getCredential(gameProfile);
profileCache.setLoading(credential, true);
logger.info("Loading " + username + "'s profile.");
if (config.loadlist == null || config.loadlist.isEmpty()) {
logger.info("LoadList is Empty.");
return null;
}
UserProfile profile0 = new UserProfile();
for (int i = 0; i < config.loadlist.size(); i++) {
SkinSiteProfile ssp = config.loadlist.get(i);
logger.info((i + 1) + "/" + config.loadlist.size() + " Try to load profile from '" + ssp.name + "'.");
if (ssp.type == null) {
logger.info("The type of '" + ssp.name + "' is null.");
continue;
}
ProfileLoader.IProfileLoader loader = ProfileLoader.LOADERS.get(ssp.type.toLowerCase());
if (loader == null) {
logger.info("Type '" + ssp.type + "' is not defined.");
continue;
}
UserProfile profile = null;
try {
profile = loader.loadProfile(ssp, gameProfile);
} catch (Exception e) {
logger.warning("Exception occurs while loading.");
logger.warning(e);
if (e.getCause() != null) {
logger.warning("Caused By:");
logger.warning(e.getCause());
}
}
if (profile == null) {
continue;
}
profile0.mix(profile);
if (isSkull && !profile0.hasSkinUrl()) {
continue;
}
if (!config.forceLoadAllTextures) {
break;
}
if (profile0.isFull()) {
break;
}
}
if (!profile0.isEmpty()) {
logger.info(username + "'s profile loaded.");
if (!config.enableCape) {
profile0.capeUrl = null;
}
profileCache.updateCache(credential, profile0);
profileCache.setLoading(credential, false);
logger.info(profile0.toString(profileCache.getExpiry(credential)));
return profile0;
}
logger.info(username + "'s profile not found in load list.");
if (config.enableLocalProfileCache) {
UserProfile profile = profileCache.getLocalProfile(credential);
if (profile == null) {
logger.info(username + "'s LocalProfile not found.");
} else {
profileCache.updateCache(credential, profile, false);
profileCache.setLoading(credential, false);
logger.info(username + "'s LocalProfile will be used.");
logger.info(profile.toString(profileCache.getExpiry(credential)));
return profile;
}
}
profileCache.setLoading(credential, false);
return null;
}
//For Skull
public static Map<MinecraftProfileTexture.Type, MinecraftProfileTexture> loadProfileFromCache(
final GameProfile gameProfile) {
String username = gameProfile.getName();
String credential = MinecraftUtil.getCredential(gameProfile);
//CustomSkinLoader needs username to load standard skin, if username not exist, only textures in NBT can be used
//Authlib 3.11.50 makes empty username to " "
if (username == null || username.isEmpty() || username.equals(" ") || credential == null) {
return dynamicSkullManager.getTexture(gameProfile);
}
if (config.forceUpdateSkull ? profileCache.isReady(credential) : profileCache.isExist(credential)) {
UserProfile profile = profileCache.getProfile(credential);
return ModelManager0.fromUserProfile(profile);
}
if (!profileCache.isLoading(credential)) {
profileCache.setLoading(credential, true);
Runnable loadThread = () -> {
String tempName = Thread.currentThread().getName();
Thread.currentThread().setName(username + "'s skull");
loadProfile0(gameProfile, true);//Load in thread
Thread.currentThread().setName(tempName);
};
if (config.forceUpdateSkull) {
new Thread(loadThread).start();
} else {
threadPool.execute(loadThread);
}
}
return Maps.newHashMap();
}
private static Logger initLogger() {
LogManager.setLogFile(LOG_FILE.toPath());
Logger logger = LogManager.getLogger("Core");
logger.info("CustomSkinLoader " + CustomSkinLoader_FULL_VERSION);
logger.info("DataDir: " + DATA_DIR.getAbsolutePath());
logger.info("Operating System: " + System.getProperty("os.name") +
" (" + System.getProperty("os.arch") + ") version " + System.getProperty("os.version"));
logger.info("Java Version: " + System.getProperty("java.version") +
", " + System.getProperty("java.vendor"));
logger.info("Java VM Version: " + System.getProperty("java.vm.name") +
" (" + System.getProperty("java.vm.info") + "), " + System.getProperty("java.vm.vendor"));
logger.info("Minecraft: " + MinecraftUtil.getMinecraftMainVersion());
return logger;
}
/**
* Create <code>Config</code> object.
* To use <code>logger</code>, please make sure call this function after <code>initLogger</code>.
*
* @return <code>Config</code>
*/
private static Config initConfig() {
Config config = Config.loadConfig0();
logger.enableLogStdOut = config.enableLogStdOut;
return config;
}
}
@@ -0,0 +1,8 @@
package customskinloader;
/**
* @deprecated From 14.16, use <code>customskinloader.log.Logger</code> instead.
*/
@Deprecated
public class Logger extends customskinloader.log.Logger {
}
@@ -0,0 +1,259 @@
package customskinloader.config;
import java.io.File;
import java.lang.reflect.Field;
import java.util.*;
import customskinloader.CustomSkinLoader;
import customskinloader.loader.ProfileLoader;
import customskinloader.plugin.ICustomSkinLoaderPlugin;
import customskinloader.plugin.PluginLoader;
import customskinloader.utils.HttpRequestUtil;
import customskinloader.utils.HttpTextureUtil;
import customskinloader.utils.HttpUtil0;
import customskinloader.utils.Version;
import org.apache.commons.io.FileUtils;
@SuppressWarnings("ResultOfMethodCallIgnored")
public class Config {
//Program
public String version;
public int buildNumber;
public List<SkinSiteProfile> loadlist;
//Function
public boolean enableDynamicSkull = true;
public boolean enableTransparentSkin = true;
public boolean forceIgnoreHttpsCertificate = false;
public boolean forceLoadAllTextures = true;
public boolean enableCape = true;
public int threadPoolSize = 8;
/**
* Can logger write message to standard output(System.out).
* Because standard output won't write to latest.log after Forge 1.17,
* printing to standard output is meaningless,
* which makes this switch default value is <code>false</code>.
* @since 14.15
*/
public boolean enableLogStdOut = false;
//Profile Cache
public int cacheExpiry = 30;
public boolean forceUpdateSkull = false;
public boolean enableLocalProfileCache = false;
//Network Cache
public boolean enableCacheAutoClean = false;
public boolean forceDisableCache = false;
// Used by Gson to create an instance with default value.
public Config() {
this(new ArrayList<>());
}
//Init config
public Config(List<SkinSiteProfile> loadlist) {
this.version = CustomSkinLoader.CustomSkinLoader_VERSION;
this.buildNumber = CustomSkinLoader.CustomSkinLoader_BUILD_NUMBER;
this.loadlist = loadlist;
}
public static Config loadConfig0() {
Config config = loadConfig();
//LoadList null checker
if (config.loadlist == null) {
config.loadlist = new ArrayList<>();
} else {
for (int i = 0; i < config.loadlist.size(); i++) {
if (config.loadlist.get(i) == null)
config.loadlist.remove(i--);
}
}
//Init program
config.loadExtraList();
config.updateLoadlist();
config.initLocalFolder();
config.threadPoolSize = Math.max(config.threadPoolSize, 1);
if (config.forceIgnoreHttpsCertificate)
HttpUtil0.ignoreHttpsCertificate();
if (config.enableCacheAutoClean && !config.enableLocalProfileCache) {
try {
FileUtils.deleteDirectory(HttpRequestUtil.CACHE_DIR);
FileUtils.deleteDirectory(HttpTextureUtil.getCacheDir());
CustomSkinLoader.logger.info("Successfully cleaned cache.");
} catch (Exception e) {
CustomSkinLoader.logger.warning("Exception occurs while cleaning cache: " + e);
}
}
//Check config version
Version configVersion = Version.of(config.version);
if (CustomSkinLoader.CustomSkinLoader_BUILD_NUMBER == 0 // Custom builds
|| configVersion.compareTo(CustomSkinLoader.CustomSkinLoader_VERSION) < 0
|| config.buildNumber < CustomSkinLoader.CustomSkinLoader_BUILD_NUMBER) {
CustomSkinLoader.logger.info("Config File is out of date: " + config.version +
", build number: " + config.buildNumber);
config.version = CustomSkinLoader.CustomSkinLoader_VERSION;
config.buildNumber = CustomSkinLoader.CustomSkinLoader_BUILD_NUMBER;
}
writeConfig(config, true);
//Output config
for (Field field : config.getClass().getDeclaredFields()) {
try {
Object value = field.get(config);
CustomSkinLoader.logger.info(field.getName() + " : " + value);
} catch (Exception ignored) {
}
}
return config;
}
private static Config loadConfig() {
CustomSkinLoader.logger.info("Config File: " + CustomSkinLoader.CONFIG_FILE.getAbsolutePath());
if (!CustomSkinLoader.CONFIG_FILE.exists()) {
CustomSkinLoader.logger.info("Config file not found, use default instead.");
return initConfig();
}
try {
CustomSkinLoader.logger.info("Try to load config.");
String json = FileUtils.readFileToString(CustomSkinLoader.CONFIG_FILE, "UTF-8");
Config config = Objects.requireNonNull(CustomSkinLoader.GSON.fromJson(json, Config.class));
CustomSkinLoader.logger.info("Successfully load config.");
return config;
} catch (Exception e) {
CustomSkinLoader.logger.info("Failed to load config, use default instead.(" + e + ")");
createBrokenFile(CustomSkinLoader.CONFIG_FILE);
return initConfig();
}
}
private void loadExtraList() {
File listAddition = new File(CustomSkinLoader.DATA_DIR, "ExtraList");
if (!listAddition.isDirectory()) {
listAddition.mkdirs();
return;
}
List<SkinSiteProfile> adds = new ArrayList<>();
File[] files = listAddition.listFiles();
for (File file : files != null ? files : new File[0]) {
if (!file.getName().toLowerCase().endsWith(".json") && !file.getName().toLowerCase().endsWith(".txt"))
continue;
try {
CustomSkinLoader.logger.info("Try to load Extra List.(" + file.getName() + ")");
String json = FileUtils.readFileToString(file, "UTF-8");
SkinSiteProfile ssp = CustomSkinLoader.GSON.fromJson(json, SkinSiteProfile.class);
CustomSkinLoader.logger.info("Successfully load Extra List.");
if (ssp.type != null) {
ProfileLoader.IProfileLoader loader = ProfileLoader.LOADERS.get(ssp.type.toLowerCase());
if (loader == null) {
CustomSkinLoader.logger.info("Extra List will be ignored: Type '" + ssp.type +
"' is not defined.");
continue;
}
boolean duplicate = false;
for (SkinSiteProfile ssp0 : this.loadlist) {
if (!ssp0.type.equalsIgnoreCase(ssp.type))
continue;
if (loader.compare(ssp0, ssp)) {
duplicate = true;
break;
}
}
if (!duplicate) {
adds.add(ssp);
CustomSkinLoader.logger.info("Successfully apply Extra List.(" + ssp.name + ")");
} else {
CustomSkinLoader.logger.info("Extra List will be ignored: Duplicate.(" + ssp.name + ")");
}
file.delete();
} else {
CustomSkinLoader.logger.info("Extra List is invalid: Type is not defined.(" +
file.getName() + ")");
createBrokenFile(file);
}
} catch (Exception e) {
CustomSkinLoader.logger.info("Failed to load Extra List.(" + e + ")");
createBrokenFile(file);
}
}
if (adds.size() != 0) {
adds.addAll(this.loadlist);
this.loadlist = adds;
}
}
private void updateLoadlist() {
PluginLoader.PLUGINS.stream()
.map(ICustomSkinLoaderPlugin::getDefaultProfiles)
.filter(Objects::nonNull)
.flatMap(Collection::stream)
.forEach(profile -> this.loadlist.stream()
.filter(ssp -> profile.getName().equals(ssp.name))
.forEach(profile::updateSkinSiteProfile));
}
private void initLocalFolder() {
for (SkinSiteProfile ssp : this.loadlist) {
if (ssp.type == null)
continue;
ProfileLoader.IProfileLoader loader = ProfileLoader.LOADERS.get(ssp.type.toLowerCase());
if (loader == null)
continue;
loader.init(ssp);
}
}
private static void createBrokenFile(File file) {
try {
File brokenFile = new File(file.getParentFile(), file.getName() + ".broken");
if (brokenFile.exists()) {
brokenFile.delete();
}
file.renameTo(brokenFile);
} catch (Exception e) {
CustomSkinLoader.logger.warning("Failed to create broken file. (" + file.getName() + ")");
CustomSkinLoader.logger.warning(e);
}
}
// The config file does not exist or was broken.
private static Config initConfig() {
List<ICustomSkinLoaderPlugin.IDefaultProfile> profiles = new ArrayList<>();
for (ICustomSkinLoaderPlugin plugin : PluginLoader.PLUGINS) {
List<ICustomSkinLoaderPlugin.IDefaultProfile> defaultProfiles = plugin.getDefaultProfiles();
if (defaultProfiles != null) {
profiles.addAll(defaultProfiles);
}
}
profiles.sort(Comparator.comparingInt(ICustomSkinLoaderPlugin.IDefaultProfile::getPriority));
List<SkinSiteProfile> loadlist = new ArrayList<>();
for (ICustomSkinLoaderPlugin.IDefaultProfile profile : profiles) {
SkinSiteProfile ssp = new SkinSiteProfile();
ssp.name = profile.getName();
profile.updateSkinSiteProfile(ssp);
loadlist.add(ssp);
}
Config config = new Config(loadlist);
writeConfig(config, false);
return config;
}
private static void writeConfig(Config config, boolean update) {
String json = CustomSkinLoader.GSON.toJson(config);
if (CustomSkinLoader.CONFIG_FILE.exists())
CustomSkinLoader.CONFIG_FILE.delete();
try {
CustomSkinLoader.CONFIG_FILE.createNewFile();
FileUtils.write(CustomSkinLoader.CONFIG_FILE, json, "UTF-8");
CustomSkinLoader.logger.info("Successfully " + (update ? "update" : "create") + " config.");
} catch (Exception e) {
CustomSkinLoader.logger.info("Failed to " + (update ? "update" : "create") + " config.(" + e + ")");
}
}
}
@@ -0,0 +1,44 @@
package customskinloader.config;
import java.lang.reflect.Field;
public class SkinSiteProfile {
//Common
public String name;
public String type;
public String userAgent;
//Mojang API
public String apiRoot;
public String sessionRoot;
//Json API
public String root;
//Legacy
public Boolean checkPNG;//Not suitable for local skin
public String skin;
public String model;
public String cape;
public String elytra;
@Override
public String toString() {
StringBuilder sb = new StringBuilder("{ ");
Field[] fields = SkinSiteProfile.class.getDeclaredFields();
boolean first = true;
for (Field field : fields) {
try {
Object value = field.get(this);
if (value == null) continue;
if (first) {
first = false;
} else {
sb.append(", ");
}
sb.append("\"").append(field.getName()).append("\": \"").append(value).append("\"");
} catch (Exception ignored) { }
}
return sb.append(" }").toString();
}
}
@@ -0,0 +1,269 @@
package customskinloader.fake;
import java.io.IOException;
import java.io.InputStream;
import java.util.NoSuchElementException;
import java.util.function.BiPredicate;
import java.util.function.Predicate;
import customskinloader.fake.itf.FakeInterfaceManager;
import customskinloader.fake.texture.FakeBufferedImage;
import customskinloader.fake.texture.FakeImage;
import customskinloader.utils.MinecraftUtil;
import net.minecraft.client.Minecraft;
import net.minecraft.util.ResourceLocation;
public class FakeCapeBuffer extends FakeSkinBuffer {
private static final ResourceLocation TEXTURE_ELYTRA = new ResourceLocation("textures/entity/elytra.png");
private static int loadedGlobal = 0;
private static FakeImage elytraImage;
private static FakeImage loadElytra(FakeImage originalImage) {
loadedGlobal++;
try {
InputStream is = FakeInterfaceManager.IResource_getInputStream(FakeInterfaceManager.IResourceManager_getResource(FakeInterfaceManager.Minecraft_getResourceManager(Minecraft.getMinecraft()), TEXTURE_ELYTRA).get());
if (is != null) {
FakeImage image = originalImage.createImage(is);
if (image.getWidth() % 64 != 0 || image.getHeight() % 32 != 0) { // wtf?
return elytraImage;
}
image = resetImageFormat(image, 22, 0, 46, 22);
return image;
}
} catch (IOException | NoSuchElementException ignored) {
}
return null;
}
private int loaded = 0;
private double ratioX = -1;
private double ratioY = -1;
private final ResourceLocation location;
private String type = null;
public FakeCapeBuffer(ResourceLocation location) {
this.location = location;
}
@Override
public FakeImage parseUserSkin(FakeImage image) {
if (image == null) return null;
if (isOptiFineCape(image)) {
//OptiFine cape should be converted to standard cape
this.image = convertOptiFineCape(image);
//OptiFine cape contains elytra texture
//this.type = "elytra";//But its elytra texture doesn't work
} else {
this.image = image;
}
// When resource packs were changed, the elytra image needs to be reloaded, and here will be entered again
// The first cape which find elytra texture is outdated will reload it
if (this.loaded == loadedGlobal) {
elytraImage = loadElytra(this.image);
}
this.loaded = loadedGlobal;
if (elytraImage != null) {
if (this.ratioX < 0)
this.ratioX = this.image.getWidth() / 64.0D;
if (this.ratioY < 0)
this.ratioY = this.image.getHeight() / 32.0D;
if (this.type == null)
this.type = this.judgeType();
if ("cape".equals(this.type)) {
this.image = resetImageFormat(this.image, 0, 0, 22, 17);
this.attachElytra(elytraImage);
if (this.image instanceof FakeBufferedImage) { // before 1.12.2
this.refreshTexture((FakeBufferedImage) this.image);
}
}
}
return this.image;
}
/**
* Judge the cape type
*
* @return "elytra" if the cape contains elytra texture, otherwise "cape"
*/
@Override
public String judgeType() {
if (this.image != null && elytraImage != null) {
// If all the pixels in ((22, 0), (45, 21)) is same as background, it means the cape doesn't contain elytra
Predicate<Integer> predicate = EQU_BG.apply(this.image.getRGBA(this.image.getWidth() - 1, this.image.getHeight() - 1));
return withElytraPixels((x, y) -> !predicate.test(this.image.getRGBA(x, y)), "elytra", "cape");
}
return "cape";
}
private void attachElytra(FakeImage elytraImage) {
if (this.image != null) {
int capeW = this.image.getWidth(), capeH = this.image.getHeight();
int elytraW = elytraImage.getWidth(), elytraH = elytraImage.getHeight();
// scale cape and elytra to the same size
// cape part ((0, 0), (21, 16)) -> (22 * 17)
if (capeW < elytraW) {
this.image = scaleImage(this.image, true, elytraW / (double) capeW, 1, capeW / 64.0D, capeH / 32.0D, elytraW, capeH, 0, 0, 22, 17);
capeW = elytraW;
}
if (capeH < elytraH) {
this.image = scaleImage(this.image, true, 1, elytraH / (double) capeH, capeW / 64.0D, capeH / 32.0D, capeW, elytraH, 0, 0, 22, 17);
capeH = elytraH;
}
// elytra part ((22, 0), (45, 21)) -> (24 * 22)
if (elytraW < capeW) {
elytraImage = scaleImage(elytraImage, false, capeW / (double) elytraW, 1, elytraW / 64.0D, elytraH / 32.0D, capeW, elytraH, 22, 0, 46, 22);
elytraW = capeW;
}
if (elytraH < capeH) {
elytraImage = scaleImage(elytraImage, false, 1, capeH / (double) elytraH, elytraW / 64.0D, elytraH / 32.0D, elytraW, capeH, 22, 0, 46, 22);
elytraH = capeH;
}
this.ratioX = capeW / 64.0D;
this.ratioY = capeH / 32.0D;
// Overwrite pixels from elytra to cape
FakeImage finalElytraImage = elytraImage;
withElytraPixels((x, y) -> {
this.image.setRGBA(x, y, finalElytraImage.getRGBA(x, y));
return false;
}, null, null);
}
}
/**
* Traverse every elytra pixel
*
* @param predicate the predicate with x and y
* @param returnValue if the condition flag equals the condition, then return this value
* @param defaultReturnValue otherwise return this value
*/
private <R> R withElytraPixels(BiPredicate<Integer, Integer> predicate, R returnValue, R defaultReturnValue) {
int startX = (int) Math.ceil(22 * ratioX), endX = (int) Math.ceil(46 * ratioX);
int startY = (int) Math.ceil(0 * ratioY), endY = (int) Math.ceil(22 * ratioY);
int excludeX0 = (int) Math.ceil(24 * ratioX), excludeX1 = (int) Math.ceil(44 * ratioX);
int excludeY = (int) Math.ceil(2 * ratioY);
for (int x = startX; x < endX; ++x) {
for (int y = startY; y < endY; ++y) {
if (y < excludeY && (x < excludeX0 || x >= excludeX1)) continue;
if (predicate.test(x, y)) {
return returnValue;
}
}
}
return defaultReturnValue;
}
// TextureID won't be regenerated when changing resource packs before 1.12.2
private void refreshTexture(FakeBufferedImage image) {
Object textureObj = MinecraftUtil.getTextureManager().getTexture(this.location);
if (textureObj != null) {
// NOTICE: OptiFine modified the upload process of the texture from ThreadDownloadImageData
// Therefore, it may not be correct to simply copy the vanilla behavior
FakeInterfaceManager.ThreadDownloadImageData_resetNewBufferedImage(textureObj, image.getImage());
}
}
// Some cape image doesn't support alpha channel, so reset image format to ARGB
private static FakeImage resetImageFormat(FakeImage image, int startX, int startY, int endX, int endY) {
if (image != null) {
int width = image.getWidth(), height = image.getHeight();
image = scaleImage(image, true, 1, 1, width / 64.0D, height / 32.0D, width, height, startX, startY, endX, endY);
}
return image;
}
/**
* Scale image
*
* @param image the image to scale.
* @param closeOldImage whether close old image
* @param scaleWidth width enlargement ratio
* @param scaleHeight height enlargement ratio
* @param ratioX the ratio of 64 of the old image width
* @param ratioY the ratio of 32 of the old image height
* @param width the width after scaling.
* @param height the height after scaling.
* @param startX the x where start to copy.
* @param startY the y where start to copy.
* @param endX the x where end to copy.
* @param endY the y where end to copy.
* @return the image after scaling.
*/
private static FakeImage scaleImage(FakeImage image, boolean closeOldImage, double scaleWidth, double scaleHeight, double ratioX, double ratioY, int width, int height, int startX, int startY, int endX, int endY) {
FakeImage newImage = image.createImage(width, height);
startX = (int) (startX * ratioX);
endX = (int) (endX * ratioX);
startY = (int) (startY * ratioY);
endY = (int) (endY * ratioY);
int x0 = (int) (startX * scaleWidth), x1 = (int) ((startX + 1) * scaleWidth), dx0 = x1 - x0;
for (int x = startX; x < endX; ++x) {
int y0 = (int) (startY * scaleHeight), y1 = (int) ((startY + 1) * scaleHeight), dy0 = y1 - y0;
for (int y = startY; y < endY; ++y) {
int rgba = image.getRGBA(x, y);
for (int dx = 0; dx < dx0; dx++) {
for (int dy = 0; dy < dy0; dy++) {
newImage.setRGBA(x0 + dx, y0 + dy, rgba);
}
}
y0 = y1;
y1 = (int) ((y + 2) * scaleHeight);
dy0 = y1 - y0;
}
x0 = x1;
x1 = (int) ((x + 2) * scaleWidth);
dx0 = x1 - x0;
}
if (closeOldImage)
image.close();
return newImage;
}
/**
* Judge OptiFine cape.
* OptiFine cape is 46*22 or 92*44 pixels.
* <a href="https://optifine.net/capes/Notch.png">46*22 example</a>
* <a href="https://optifine.net/capes/OptiFineCape.png">92*44 example</a>
*
* @param image cape image
* @return true if is OptiFine cape
* @since 14.16
*/
private static boolean isOptiFineCape(FakeImage image) {
int ratio = image.getWidth() / 46;
return image.getHeight() == 22 * ratio && image.getWidth() == 46 * ratio;
}
/**
* Convert OptiFine cape to standard cape
*
* @param image OptiFine cape image
* @return standard cape image
* @since 14.16
*/
private static FakeImage convertOptiFineCape(FakeImage image) {
int ratio = image.getWidth() / 46;
FakeImage newImage = image.createImage(64 * ratio, 32 * ratio);
copyImageData(image, newImage);
return newImage;
}
/**
* Copy image data to another image
*
* @param from from image
* @param to to image
*/
private static void copyImageData(FakeImage from, FakeImage to) {
int width = Math.min(from.getWidth(), to.getWidth());
int height = Math.min(from.getHeight(), to.getHeight());
for (int x = 0; x < width; ++x) {
for (int y = 0; y < height; ++y) {
to.setRGBA(x, y, from.getRGBA(x, y));
}
}
}
}
@@ -0,0 +1,99 @@
package customskinloader.fake;
import java.util.Map;
import java.util.UUID;
import com.google.common.collect.Maps;
import com.mojang.authlib.GameProfile;
import com.mojang.authlib.minecraft.MinecraftProfileTexture;
import com.mojang.authlib.minecraft.MinecraftProfileTexture.Type;
import customskinloader.CustomSkinLoader;
import customskinloader.utils.MinecraftUtil;
import net.minecraft.client.renderer.ThreadDownloadImageData;
import net.minecraft.client.renderer.texture.ITextureObject;
import net.minecraft.client.renderer.texture.SimpleTexture;
import net.minecraft.client.renderer.texture.TextureManager;
import net.minecraft.client.resources.DefaultPlayerSkin;
import net.minecraft.client.resources.SkinManager;
import net.minecraft.client.resources.SkinManager.SkinAvailableCallback;
import net.minecraft.util.ResourceLocation;
import net.minecraft.util.StringUtils;
public class FakeClientPlayer {
/**
* Invoked from {@link SkinManager#loadSkin(MinecraftProfileTexture, MinecraftProfileTexture.Type, SkinManager.SkinAvailableCallback)}
*/
public static ThreadDownloadImageData putCache(ThreadDownloadImageData threaddownloadimagedata, SkinManager.SkinAvailableCallback skinAvailableCallback, ResourceLocation resourcelocation) {
if (skinAvailableCallback instanceof FakeClientPlayer.LegacyBuffer) {//Cache for client player
textureCache.put(resourcelocation, threaddownloadimagedata);
}
return threaddownloadimagedata;
}
//For Legacy Skin
public static ThreadDownloadImageData getDownloadImageSkin(ResourceLocation resourceLocationIn, String username) {
//CustomSkinLoader.logger.debug("FakeClientPlayer/getDownloadImageSkin "+username);
TextureManager textman = MinecraftUtil.getTextureManager();
ITextureObject ito = textman.getTexture(resourceLocationIn);
if (ito == null || !(ito instanceof ThreadDownloadImageData)) {
//if Legacy Skin for username not loaded yet
SkinManager skinman = MinecraftUtil.getSkinManager();
UUID offlineUUID = getOfflineUUID(username);
GameProfile offlineProfile = new GameProfile(offlineUUID, username);
//Load Default Skin
ResourceLocation defaultSkin = DefaultPlayerSkin.getDefaultSkin(offlineUUID);
ITextureObject defaultSkinObj = new SimpleTexture(defaultSkin);
textman.loadTexture(resourceLocationIn, defaultSkinObj);
//Load Skin from SkinManager
skinman.loadProfileTextures(offlineProfile, new LegacyBuffer(resourceLocationIn), false);
}
if (ito instanceof ThreadDownloadImageData)
return (ThreadDownloadImageData) ito;
else
return null;
}
public static ResourceLocation getLocationSkin(String username) {
//CustomSkinLoader.logger.debug("FakeClientPlayer/getLocationSkin "+username);
return new ResourceLocation("skins/legacy-" + StringUtils.stripControlCodes(username));
}
public static UUID getOfflineUUID(String username) {
return UUID.nameUUIDFromBytes(("OfflinePlayer:" + username).getBytes());
}
public static Map<ResourceLocation, ITextureObject> textureCache = Maps.newHashMap();
public static class LegacyBuffer implements SkinAvailableCallback {
ResourceLocation resourceLocationIn;
boolean loaded = false;
public LegacyBuffer(ResourceLocation resourceLocationIn) {
CustomSkinLoader.logger.debug("Loading Legacy Texture (" + resourceLocationIn + ")");
this.resourceLocationIn = resourceLocationIn;
}
@Override
public void skinAvailable(Type typeIn, ResourceLocation location, MinecraftProfileTexture profileTexture) {
if (typeIn != Type.SKIN || loaded)
return;
TextureManager textman = MinecraftUtil.getTextureManager();
ITextureObject ito = textman.getTexture(location);
if (ito == null)
ito = textureCache.get(location);
if (ito == null)
return;
loaded = true;
textman.loadTexture(resourceLocationIn, ito);
CustomSkinLoader.logger.debug("Legacy Texture (" + resourceLocationIn + ") Loaded as " +
ito.toString() + " (" + location + ")");
}
}
}
@@ -0,0 +1,40 @@
package customskinloader.fake;
import java.io.File;
import java.util.Map;
import com.mojang.authlib.minecraft.MinecraftProfileTexture;
import customskinloader.utils.HttpTextureUtil;
import net.minecraft.util.ResourceLocation;
public class FakeMinecraftProfileTexture extends MinecraftProfileTexture {
private HttpTextureUtil.HttpTextureInfo info;
private ResourceLocation resourceLocation;
public FakeMinecraftProfileTexture(String url, Map<String, String> metadata) {
super(url, metadata);
this.info = HttpTextureUtil.toHttpTextureInfo(url);
}
public void setResourceLocation(ResourceLocation resourceLocation) {
this.resourceLocation = resourceLocation;
}
public ResourceLocation getResourceLocation() {
return this.resourceLocation;
}
@Override
public String getUrl() {
return this.info.url;
}
@Override
public String getHash() {
return this.info.hash;
}
public File getCacheFile() {
return this.info.cacheFile;
}
}
@@ -0,0 +1,186 @@
package customskinloader.fake;
import java.awt.image.BufferedImage;
import java.util.function.Function;
import java.util.function.Predicate;
import customskinloader.CustomSkinLoader;
import customskinloader.fake.texture.FakeBufferedImage;
import customskinloader.fake.texture.FakeImage;
import customskinloader.fake.texture.FakeNativeImage;
import net.minecraft.client.renderer.IImageBuffer;
import net.minecraft.client.renderer.texture.NativeImage;
public class FakeSkinBuffer implements IImageBuffer {
private int ratio = 1;
FakeImage image = null;
//parseUserSkin for 1.15+
public static NativeImage processLegacySkin(NativeImage image, Runnable processTask, Function<NativeImage, NativeImage> processLegacySkin) {
if (processTask instanceof IImageBuffer) {
return ((IImageBuffer) processTask).func_195786_a(image);
}
return processLegacySkin.apply(image);
}
//parseUserSkin for 1.13+
public NativeImage func_195786_a(NativeImage image) {
if (image == null)
return null;
FakeImage img = parseUserSkin(new FakeNativeImage(image));
if (img instanceof FakeNativeImage)
return ((FakeNativeImage) img).getImage();
CustomSkinLoader.logger.warning("Failed to parseUserSkin(func_195786_a).");
return null;
}
//parseUserSkin for 1.12.2-
public BufferedImage parseUserSkin(BufferedImage image) {
if (image == null)
return null;
FakeImage img = parseUserSkin(new FakeBufferedImage(image));
if (img instanceof FakeBufferedImage)
return ((FakeBufferedImage) img).getImage();
CustomSkinLoader.logger.warning("Failed to parseUserSkin.");
return null;
}
public FakeImage parseUserSkin(FakeImage image) {
if (image == null) return null;
this.ratio = image.getWidth() / 64;
if (image.getHeight() != image.getWidth()) {//Single Layer
//Create a new image and copy origin image data
FakeImage img = image.createImage(64 * ratio, 64 * ratio);
img.copyImageData(image);
image.close();
image = img;
image.fillArea(0 * ratio, 32 * ratio, 64 * ratio, 32 * ratio);
//Right Leg -> Left Leg
image.copyArea(4 * ratio, 16 * ratio, 16 * ratio, 32 * ratio, 4 * ratio, 4 * ratio, true, false);//Top
image.copyArea(8 * ratio, 16 * ratio, 16 * ratio, 32 * ratio, 4 * ratio, 4 * ratio, true, false);//Bottom
image.copyArea(0 * ratio, 20 * ratio, 24 * ratio, 32 * ratio, 4 * ratio, 12 * ratio, true, false);//Right
image.copyArea(4 * ratio, 20 * ratio, 16 * ratio, 32 * ratio, 4 * ratio, 12 * ratio, true, false);//Front
image.copyArea(8 * ratio, 20 * ratio, 8 * ratio, 32 * ratio, 4 * ratio, 12 * ratio, true, false);//Left
image.copyArea(12 * ratio, 20 * ratio, 16 * ratio, 32 * ratio, 4 * ratio, 12 * ratio, true, false);//Back
//Right Arm -> Left Arm
image.copyArea(44 * ratio, 16 * ratio, -8 * ratio, 32 * ratio, 4 * ratio, 4 * ratio, true, false);//Top
image.copyArea(48 * ratio, 16 * ratio, -8 * ratio, 32 * ratio, 4 * ratio, 4 * ratio, true, false);//Bottom
image.copyArea(40 * ratio, 20 * ratio, 0 * ratio, 32 * ratio, 4 * ratio, 12 * ratio, true, false);//Right
image.copyArea(44 * ratio, 20 * ratio, -8 * ratio, 32 * ratio, 4 * ratio, 12 * ratio, true, false);//Front
image.copyArea(48 * ratio, 20 * ratio, -16 * ratio, 32 * ratio, 4 * ratio, 12 * ratio, true, false);//Left
image.copyArea(52 * ratio, 20 * ratio, -8 * ratio, 32 * ratio, 4 * ratio, 12 * ratio, true, false);//Back
}
this.image = image;
setAreaDueToConfig(0 * ratio, 0 * ratio, 32 * ratio, 16 * ratio);//Head - 1
setAreaTransparent(32 * ratio, 0 * ratio, 64 * ratio, 16 * ratio);//Head - 2
setAreaDueToConfig(16 * ratio, 16 * ratio, 40 * ratio, 32 * ratio);//Body - 1
setAreaTransparent(16 * ratio, 32 * ratio, 40 * ratio, 48 * ratio);//Body - 2
setAreaDueToConfig(40 * ratio, 16 * ratio, 56 * ratio, 32 * ratio);//Right Arm - 1
setAreaTransparent(40 * ratio, 32 * ratio, 56 * ratio, 48 * ratio);//Right Arm - 2
setAreaDueToConfig(0 * ratio, 16 * ratio, 16 * ratio, 32 * ratio);//Right Leg - 1
setAreaTransparent(0 * ratio, 32 * ratio, 16 * ratio, 48 * ratio);//Right Leg - 2
setAreaDueToConfig(32 * ratio, 48 * ratio, 48 * ratio, 64 * ratio);//Left Arm - 1
setAreaTransparent(48 * ratio, 48 * ratio, 64 * ratio, 64 * ratio);//Left Arm - 2
setAreaDueToConfig(16 * ratio, 48 * ratio, 32 * ratio, 64 * ratio);//Left Leg - 1
setAreaTransparent(0 * ratio, 48 * ratio, 16 * ratio, 64 * ratio);//Left Leg - 2
return image;
}
/** Judge if the color is transparent or same with background */
static final Function<Integer, Predicate<Integer>> EQU_BG = bgColor -> getA(bgColor) == 0 ? (c) -> getA(c) == 0 : (c) -> c.equals(bgColor);
/**
* Judge the type of skin
* Must be called after parseUserSkin
*
* @return type of skin (slim / default)
* @since 14.9
*/
public String judgeType() {
if (this.image == null)
return "default";
int bgColor = image.getRGBA(63 * ratio, 20 * ratio);
/*
* If background is transparent, all the pixels in ((54, 20), (55, 31)) areas is transparent,
* which means it is Alex model.
* If background is opaque, all the pixels in ((54, 20), (55, 31)) areas is same with background,
* which means it is Alex model.
* Otherwise, it is Steve model.
* */
Predicate<Integer> predicate = EQU_BG.apply(bgColor);
for (int x = 54 * ratio; x <= 55 * ratio; ++x) {
for (int y = 20 * ratio; y <= 31 * ratio; ++y) {
int color = image.getRGBA(x, y);
if (!predicate.test(color)) {
return "default";
}
}
}
return "slim";
}
/* 2^24-1
* 00000000 11111111 11111111 11111111 */
private static final int A = 16777215;
private static final int WHITE = getARGB(255, 255, 255, 255);
private static final int BLACK = getARGB(255, 0, 0, 0);
private boolean isFilled(int x0, int y0, int x1, int y1) {
int data = image.getRGBA(x0, y0);
if (data != WHITE && data != BLACK)
return false;
for (int x = x0; x < x1; ++x)
for (int y = y0; y < y1; ++y)
if (image.getRGBA(x, y) != data)
return false;
return true;
}
private void setAreaTransparent(int x0, int y0, int x1, int y1) {
if (!isFilled(x0, y0, x1, y1))
return;
for (int x = x0; x < x1; ++x)
for (int y = y0; y < y1; ++y)
image.setRGBA(x, y, image.getRGBA(x, y) & A);
}
/* -2^24
* 00000001 00000000 00000000 00000000 ->
* 11111110 11111111 11111111 11111111 ->
* 11111111 00000000 00000000 00000000 */
private static final int B = -16777216;
private void setAreaOpaque(int x0, int y0, int x1, int y1) {
for (int x = x0; x < x1; ++x)
for (int y = y0; y < y1; ++y)
image.setRGBA(x, y, image.getRGBA(x, y) | B);
}
private void setAreaDueToConfig(int x0, int y0, int x1, int y1) {
if (customskinloader.CustomSkinLoader.config.enableTransparentSkin)
setAreaTransparent(x0, y0, x1, y1);
else
setAreaOpaque(x0, y0, x1, y1);
}
public void skinAvailable() {
//A callback when skin loaded, nothing to do
}
private static int getARGB(int a, int r, int g, int b) {
return (a << 24) | (r << 16) | (g << 8) | b;
}
private static int getA(int argb) {
return (argb & B) >>> 24;
}
}
@@ -0,0 +1,180 @@
package customskinloader.fake;
import java.awt.image.BufferedImage;
import java.io.File;
import java.util.Iterator;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Maps;
import com.google.common.collect.Multimap;
import com.mojang.authlib.GameProfile;
import com.mojang.authlib.minecraft.MinecraftProfileTexture;
import com.mojang.authlib.minecraft.MinecraftSessionService;
import customskinloader.CustomSkinLoader;
import customskinloader.utils.HttpTextureUtil;
import customskinloader.utils.MinecraftUtil;
import net.minecraft.client.renderer.texture.NativeImage;
import net.minecraft.client.renderer.IImageBuffer;
import net.minecraft.client.renderer.texture.TextureManager;
import net.minecraft.client.resources.SkinManager;
import net.minecraft.client.resources.SkinManager.SkinAvailableCallback;
import net.minecraft.util.ResourceLocation;
public class FakeSkinManager {
private final TextureManager textureManager;
private final Map<ResourceLocation, MinecraftProfileTexture> modelCache = new ConcurrentHashMap<>();
public FakeSkinManager(TextureManager textureManagerInstance, File skinCacheDirectory, MinecraftSessionService sessionService) {
this.textureManager = textureManagerInstance;
HttpTextureUtil.defaultCacheDir = skinCacheDirectory;
}
/**
* Invoked from {@link SkinManager#loadSkin(MinecraftProfileTexture, MinecraftProfileTexture.Type, SkinAvailableCallback)}
*/
public static ResourceLocation setResourceLocation(ResourceLocation resourceLocation, MinecraftProfileTexture profileTexture) {
if (profileTexture instanceof FakeMinecraftProfileTexture) {
((FakeMinecraftProfileTexture) profileTexture).setResourceLocation(resourceLocation);
}
return resourceLocation;
}
/**
* Invoked from {@link SkinManager#loadSkin(MinecraftProfileTexture, MinecraftProfileTexture.Type, SkinAvailableCallback)}
* <p>
* {@code skinAvailableCallback.skinAvailable(textureType, resourcelocation, profileTexture);} -> {@code skinAvailableCallback.skinAvailable(textureType, resourcelocation, this.fakeManager.getModelCache(profileTexture, resourcelocation));}
* <p>
*/
public static MinecraftProfileTexture getModelCache(MinecraftProfileTexture profileTexture, FakeSkinManager fakeManager, ResourceLocation location) {
return fakeManager.modelCache.getOrDefault(location, profileTexture);
}
/**
* Invoked from {@link SkinManager#loadSkin(MinecraftProfileTexture, MinecraftProfileTexture.Type, SkinAvailableCallback)}
*/
public static Object[] createThreadDownloadImageData(ImmutableList<Object> list, FakeSkinManager fakeManager, MinecraftProfileTexture profileTexture, MinecraftProfileTexture.Type textureType, SkinManager.SkinAvailableCallback skinAvailableCallback) {
Object[] params = list.toArray();
if (profileTexture instanceof FakeMinecraftProfileTexture && params.length > 1) {
FakeMinecraftProfileTexture fakeProfileTexture = (FakeMinecraftProfileTexture) profileTexture;
ResourceLocation resourcelocation = fakeProfileTexture.getResourceLocation();
if (fakeProfileTexture.getResourceLocation() != null) {
params[0] = ((FakeMinecraftProfileTexture) profileTexture).getCacheFile();
if (params[params.length - 2] instanceof Boolean) {
params[params.length - 2] = true;
}
params[params.length - 1] = fakeManager.new BaseBuffer(skinAvailableCallback, textureType, resourcelocation, profileTexture);
}
}
return params;
}
private final static String KEY = "CustomSkinLoaderInfo";
/**
* Invoked from {@link SkinManager#loadProfileTextures(GameProfile, SkinAvailableCallback, boolean)}
*/
@SuppressWarnings({ "rawtypes", "unchecked" })
public static void loadProfileTextures(Runnable runnable, GameProfile profile) {
CustomSkinLoader.loadProfileTextures(() -> CustomSkinLoader.loadProfileLazily(profile, m -> {
// This is a hack.
((Multimap) profile.getProperties()).put(KEY, m);
runnable.run();
}));
}
/**
* Invoked from {@link SkinManager#lambda$loadProfileTextures$1(GameProfile, boolean, SkinAvailableCallback)}
*/
@SuppressWarnings({ "rawtypes", "unchecked" })
public static Map<MinecraftProfileTexture.Type, MinecraftProfileTexture> getUserProfile(MinecraftSessionService sessionService, GameProfile profile, boolean requireSecure) {
// This is a hack.
return (Map<MinecraftProfileTexture.Type, MinecraftProfileTexture>) ((Optional) profile.getProperties().removeAll(KEY).stream().findFirst()).orElse(Maps.newHashMap());
}
/**
* Invoked from {@link SkinManager#lambda$null$0(Map, SkinAvailableCallback)}
*/
public static void loadElytraTexture(SkinManager skinManager, Map<MinecraftProfileTexture.Type, MinecraftProfileTexture> map, SkinManager.SkinAvailableCallback skinAvailableCallback) {
for (int i = 2; i < MinecraftProfileTexture.Type.values().length; i++) {
MinecraftProfileTexture.Type type = MinecraftProfileTexture.Type.values()[i];
if (map.containsKey(type)) {
skinManager.loadSkin(map.get(type), type, skinAvailableCallback);
}
}
}
public Map<MinecraftProfileTexture.Type, MinecraftProfileTexture> loadSkinFromCache(GameProfile profile) {
Map<MinecraftProfileTexture.Type, MinecraftProfileTexture> map = CustomSkinLoader.loadProfileFromCache(profile);
for (Iterator<Map.Entry<MinecraftProfileTexture.Type, MinecraftProfileTexture>> it = map.entrySet().iterator(); it.hasNext(); ) {
Map.Entry<MinecraftProfileTexture.Type, MinecraftProfileTexture> entry = it.next();
MinecraftProfileTexture texture = entry.getValue();
if (shouldJudgeType(texture)) {
texture = this.modelCache.get(MinecraftUtil.getSkinManager().loadSkin(texture, entry.getKey()));
if (texture == null) { // remove texture if was not loaded before
it.remove();
} else {
map.put(entry.getKey(), texture);
}
}
}
return map;
}
private static void makeCallback(SkinManager.SkinAvailableCallback callback, MinecraftProfileTexture.Type type, ResourceLocation location, MinecraftProfileTexture texture) {
if (callback != null)
callback.skinAvailable(type, location, texture);
}
private static boolean shouldJudgeType(MinecraftProfileTexture texture) {
return texture != null && "auto".equals(texture.getMetadata("model"));
}
private class BaseBuffer implements IImageBuffer {
private IImageBuffer buffer;
private SkinManager.SkinAvailableCallback callback;
private MinecraftProfileTexture.Type type;
private ResourceLocation location;
private MinecraftProfileTexture texture;
public BaseBuffer(SkinManager.SkinAvailableCallback callback, MinecraftProfileTexture.Type type, ResourceLocation location, MinecraftProfileTexture texture) {
switch (type) {
case SKIN: this.buffer = new FakeSkinBuffer(); break;
case CAPE: this.buffer = new FakeCapeBuffer(location); break;
}
this.callback = callback;
this.type = type;
this.location = location;
this.texture = texture;
}
public NativeImage func_195786_a(NativeImage image) {
return buffer instanceof FakeSkinBuffer ? ((FakeSkinBuffer) buffer).func_195786_a(image) : image;
}
public BufferedImage parseUserSkin(BufferedImage image) {
return buffer instanceof FakeSkinBuffer ? ((FakeSkinBuffer) buffer).parseUserSkin(image) : image;
}
public void skinAvailable() {
if (buffer != null) {
buffer.skinAvailable();
if (shouldJudgeType(texture) && buffer instanceof FakeSkinBuffer) {
//Auto judge skin type
Map<String, String> metadata = Maps.newHashMap();
String type = ((FakeSkinBuffer) buffer).judgeType();
metadata.put("model", type);
texture = new MinecraftProfileTexture(texture.getUrl(), metadata);
FakeSkinManager.this.modelCache.put(location, texture);
}
}
FakeSkinManager.makeCallback(callback, type, location, texture);
}
}
}
@@ -0,0 +1,29 @@
package customskinloader.fake.itf;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.io.InputStream;
import java.util.Optional;
import net.minecraft.client.Minecraft;
import net.minecraft.client.resources.IResource;
import net.minecraft.client.resources.IResourceManager;
import net.minecraft.util.ResourceLocation;
public class FakeInterfaceManager {
public static InputStream IResource_getInputStream(Object resource) {
return ((IFakeIResource.V2) resource).open();
}
public static Optional<IResource> IResourceManager_getResource(Object resourceManager, ResourceLocation location) throws IOException {
return ((IFakeIResourceManager) resourceManager).getResource(location);
}
public static IResourceManager Minecraft_getResourceManager(Minecraft minecraft) {
return (IResourceManager) ((IFakeMinecraft) minecraft).func_195551_G();
}
public static void ThreadDownloadImageData_resetNewBufferedImage(Object threadDownloadImageData, BufferedImage image) {
((IFakeThreadDownloadImageData) threadDownloadImageData).resetNewBufferedImage(image);
}
}
@@ -0,0 +1,22 @@
package customskinloader.fake.itf;
import java.io.InputStream;
import net.minecraft.client.resources.IResource;
/** {@link IResource} is no longer an interface since 22w14a */
public interface IFakeIResource {
// 1.13.2 ~ 22w13a
interface V1 {
default InputStream func_199027_b() {
return ((IResource) this).getInputStream();
}
}
// 22w14a+
interface V2 {
default InputStream open() {
return ((IFakeIResource.V1) this).func_199027_b();
}
}
}
@@ -0,0 +1,20 @@
package customskinloader.fake.itf;
import java.io.IOException;
import java.util.Optional;
import net.minecraft.client.resources.IResourceManager;
import net.minecraft.resources.IResource;
import net.minecraft.util.ResourceLocation;
public interface IFakeIResourceManager {
// 1.13.2 ~ 22w13a
default IResource func_199002_a(ResourceLocation location) throws IOException {
return (IResource) ((IResourceManager) this).getResource(location);
}
// 22w14a+
default Optional getResource(ResourceLocation location) throws IOException {
return Optional.ofNullable(this.func_199002_a(location));
}
}
@@ -0,0 +1,11 @@
package customskinloader.fake.itf;
import net.minecraft.client.Minecraft;
import net.minecraft.resources.IResourceManager;
public interface IFakeMinecraft {
// 1.13.2+
default IResourceManager func_195551_G() {
return (IResourceManager) ((Minecraft) this).getResourceManager();
}
}
@@ -0,0 +1,12 @@
package customskinloader.fake.itf;
import java.awt.image.BufferedImage;
// This interface is only available before 1.12.2
public interface IFakeThreadDownloadImageData {
/**
* Reset {@link net.minecraft.client.renderer.ThreadDownloadImageData#bufferedImage} and
* {@link net.minecraft.client.renderer.ThreadDownloadImageData#textureUploaded} to false to refresh texture.
*/
void resetNewBufferedImage(BufferedImage image);
}
@@ -0,0 +1,75 @@
package customskinloader.fake.texture;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.io.InputStream;
import javax.imageio.ImageIO;
public class FakeBufferedImage implements FakeImage {
private BufferedImage image;
private Graphics graphics;
public FakeBufferedImage(int width, int height) {
this(new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB));
}
public FakeBufferedImage(BufferedImage image) {
this.image = image;
graphics = image.getGraphics();
}
public BufferedImage getImage() {
graphics.dispose();
return image;
}
public FakeImage createImage(int width, int height) {
return new FakeBufferedImage(width, height);
}
public FakeImage createImage(InputStream is) throws IOException {
return new FakeBufferedImage(ImageIO.read(is));
}
public int getWidth() {
return image.getWidth();
}
public int getHeight() {
return image.getHeight();
}
public int getRGBA(int x, int y) {
return image.getRGB(x, y);
}
public void setRGBA(int x, int y, int rgba) {
image.setRGB(x, y, rgba);
}
public void copyImageData(FakeImage image) {
if (!(image instanceof FakeBufferedImage)) return;
BufferedImage img = ((FakeBufferedImage) image).getImage();
graphics.drawImage(img, 0, 0, null);
}
public void fillArea(int x0, int y0, int width, int height) {
graphics.setColor(new Color(0, 0, 0, 0));
graphics.fillRect(x0, y0, width, height);
}
public void copyArea(int x0, int y0, int dx, int dy, int width, int height, boolean reversex, boolean reversey) {
int x1 = x0 + width, x2 = x0 + dx, x3 = x2 + width;
int y1 = y0 + height, y2 = y0 + dy, y3 = y2 + height;
graphics.drawImage(image,
reversex ? x3 : x2, reversey ? y3 : y2,
reversex ? x2 : x3, reversey ? y2 : y3,
x0, y0, x1, y1, null);
}
public void close() {
graphics.dispose();
}
}
@@ -0,0 +1,26 @@
package customskinloader.fake.texture;
import java.io.IOException;
import java.io.InputStream;
public interface FakeImage {
FakeImage createImage(int width, int height);
FakeImage createImage(InputStream is) throws IOException;
int getWidth();
int getHeight();
int getRGBA(int x, int y);
void setRGBA(int x, int y, int rgba);
void copyImageData(FakeImage image);
void fillArea(int x0, int y0, int width, int height);
void copyArea(int x0, int y0, int dx, int dy, int width, int height, boolean reversex, boolean reversey);
void close();
}
@@ -0,0 +1,61 @@
package customskinloader.fake.texture;
import java.io.InputStream;
import net.minecraft.client.renderer.texture.NativeImage;
public class FakeNativeImage implements FakeImage {
private NativeImage image;
public FakeNativeImage(int width, int height) {
this(new NativeImage(width, height, true));
}
public FakeNativeImage(NativeImage image) {
this.image = image;
}
public NativeImage getImage() {
return image;
}
public FakeImage createImage(int width, int height) {
return new FakeNativeImage(width, height);
}
public FakeImage createImage(InputStream is) {
return new FakeNativeImage(NativeImage.func_195713_a(is));
}
public int getWidth() {
return image.func_195702_a();
}
public int getHeight() {
return image.func_195714_b();
}
public int getRGBA(int x, int y) {
return image.func_195709_a(x, y);
}
public void setRGBA(int x, int y, int rgba) {
image.func_195700_a(x, y, rgba);
}
public void copyImageData(FakeImage image) {
if (!(image instanceof FakeNativeImage)) return;
this.image.func_195703_a(((FakeNativeImage) image).getImage());
}
public void fillArea(int x0, int y0, int width, int height) {
image.func_195715_a(x0, y0, width, height, 0);
}
public void copyArea(int x0, int y0, int dx, int dy, int width, int height, boolean reversex, boolean reversey) {
image.func_195699_a(x0, y0, dx, dy, width, height, reversex, reversey);
}
public void close() {
}
}
@@ -0,0 +1,166 @@
package customskinloader.loader;
import java.io.File;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.util.List;
import com.mojang.authlib.GameProfile;
import customskinloader.CustomSkinLoader;
import customskinloader.config.SkinSiteProfile;
import customskinloader.plugin.ICustomSkinLoaderPlugin;
import customskinloader.profile.UserProfile;
import customskinloader.utils.HttpRequestUtil;
import customskinloader.utils.HttpUtil0;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.StringUtils;
public class JsonAPILoader implements ICustomSkinLoaderPlugin, ProfileLoader.IProfileLoader {
public interface IJsonAPI {
List<IDefaultProfile> getDefaultProfiles(JsonAPILoader loader);
String toJsonUrl(String root, String username);
default String getPayload(SkinSiteProfile ssp) {
return null;
}
/**
* get JSON API payload, which will make a POST request
*
* @param ssp skin site profile
* @param username username
* @return JSON payload
* @since 14.16
*/
default String getPayload(SkinSiteProfile ssp, String username) {
return getPayload(ssp);
}
UserProfile toUserProfile(String root, String json, boolean local);
String getName();
}
public static class ErrorProfile {
public int errno;
public String msg;
}
private final IJsonAPI jsonAPI;
public JsonAPILoader(IJsonAPI jsonAPI) {
this.jsonAPI = jsonAPI;
}
// === ICustomSkinLoaderPlugin ===
@Override
public ProfileLoader.IProfileLoader getProfileLoader() {
return this;
}
@Override
public List<IDefaultProfile> getDefaultProfiles() {
return this.jsonAPI.getDefaultProfiles(this);
}
public abstract static class DefaultProfile implements ICustomSkinLoaderPlugin.IDefaultProfile {
protected final JsonAPILoader loader;
public DefaultProfile(JsonAPILoader loader) {
this.loader = loader;
}
@Override
public void updateSkinSiteProfile(SkinSiteProfile ssp) {
ssp.type = this.loader.getName();
ssp.root = this.getRoot();
}
public abstract String getRoot();
}
// === IProfileLoader ===
@Override
public UserProfile loadProfile(SkinSiteProfile ssp, GameProfile gameProfile) throws Exception {
String username = gameProfile.getName();
if (StringUtils.isEmpty(ssp.root)) {
CustomSkinLoader.logger.info("Root not defined.");
return null;
}
boolean local = HttpUtil0.isLocal(ssp.root);
String jsonUrl = this.jsonAPI.toJsonUrl(ssp.root, username);
//Some API like MinecraftCapesAPI won't load profile at sometime
if (jsonUrl == null) {
CustomSkinLoader.logger.info("Profile url not found.");
return null;
}
String json;
if (local) {
File jsonFile = new File(CustomSkinLoader.DATA_DIR, jsonUrl);
if (!jsonFile.exists()) {
CustomSkinLoader.logger.info("Profile File not found.");
return null;
}
json = IOUtils.toString(Files.newInputStream(jsonFile.toPath()), StandardCharsets.UTF_8);
} else {
try {
HttpRequestUtil.HttpResponce responce = HttpRequestUtil
.makeHttpRequest(new HttpRequestUtil.HttpRequest(jsonUrl).setCacheTime(90)
.setUserAgent(ssp.userAgent).setPayload(this.jsonAPI.getPayload(ssp, username)));
json = responce.content;
} catch (ProfileNotFoundException ignored) {
CustomSkinLoader.logger.info("Profile not found.");
return null;
}
}
if (json == null || json.equals("")) {
CustomSkinLoader.logger.info("Profile not found.");
return null;
}
ErrorProfile profile = CustomSkinLoader.GSON.fromJson(json, ErrorProfile.class);
if (profile.errno != 0) {
CustomSkinLoader.logger.info("Error " + profile.errno + ": " + profile.msg);
return null;
}
UserProfile p = this.jsonAPI.toUserProfile(ssp.root, json, local);
if (p == null || p.isEmpty()) {
CustomSkinLoader.logger.info("Both skin and cape not found.");
return null;
} else {
return p;
}
}
@Override
public boolean compare(SkinSiteProfile ssp0, SkinSiteProfile ssp1) {
return !StringUtils.isNoneEmpty(ssp0.root) || ssp0.root.equalsIgnoreCase(ssp1.root);
}
@Override
public String getName() {
return this.jsonAPI.getName();
}
@Override
public void init(SkinSiteProfile ssp) {
if (HttpUtil0.isLocal(ssp.root)) {
File f = new File(ssp.root);
if (!f.exists())
//noinspection ResultOfMethodCallIgnored
f.mkdirs();
}
}
/**
* When getting payload, this exception can end skin loading
* @since 14.16
*/
public static class ProfileNotFoundException extends RuntimeException {
}
}
@@ -0,0 +1,236 @@
package customskinloader.loader;
import java.io.File;
import java.util.List;
import java.util.Objects;
import java.util.function.Consumer;
import com.google.common.collect.Lists;
import com.mojang.authlib.GameProfile;
import customskinloader.CustomSkinLoader;
import customskinloader.config.SkinSiteProfile;
import customskinloader.plugin.ICustomSkinLoaderPlugin;
import customskinloader.profile.UserProfile;
import customskinloader.utils.HttpRequestUtil;
import customskinloader.utils.HttpTextureUtil;
import customskinloader.utils.HttpUtil0;
public class LegacyLoader implements ICustomSkinLoaderPlugin, ProfileLoader.IProfileLoader {
@Override
public ProfileLoader.IProfileLoader getProfileLoader() {
return this;
}
@Override
public List<IDefaultProfile> getDefaultProfiles() {
return Lists.newArrayList(new LocalSkin(this),
getCapeProfile(this, "OptiFine", "https://optifine.net/capes/{USERNAME}.png", 810),
getCapeProfile(this, "CloakPlus", "http://161.35.130.99/capes/{USERNAME}.png", 840),
getCapeProfile(this, "LabyMod", "https://dl.labymod.net/capes/{STANDARD_UUID}", 850),
getCapeProfile(this, "Cosmetica", "https://api.cosmetica.cc/get/cloak?username={USERNAME}&uuid={STANDARD_UUID}&nothirdparty", 860)
);
}
public abstract static class DefaultProfile implements ICustomSkinLoaderPlugin.IDefaultProfile {
protected final LegacyLoader loader;
public DefaultProfile(LegacyLoader loader) {
this.loader = loader;
}
@Override
public void updateSkinSiteProfile(SkinSiteProfile ssp) {
ssp.type = this.loader.getName();
if (ssp.checkPNG == null) {
ssp.checkPNG = false;
}
if (ssp.model == null) {
ssp.model = "auto";
}
//Set texture url when it is empty
//Remote texture url could be changed, it will be auto updated here
if (ssp.skin == null || !HttpUtil0.isLocal(this.getSkinRoot())) {
ssp.skin = this.getSkinRoot();
}
if (ssp.cape == null || !HttpUtil0.isLocal(this.getCapeRoot())) {
ssp.cape = this.getCapeRoot();
}
if (ssp.elytra == null || !HttpUtil0.isLocal(this.getElytraRoot())) {
ssp.elytra = this.getElytraRoot();
}
}
public abstract String getSkinRoot();
public abstract String getCapeRoot();
public abstract String getElytraRoot();
}
public static class LocalSkin extends LegacyLoader.DefaultProfile {
public LocalSkin(LegacyLoader loader) {
super(loader);
}
@Override
public String getName() {
return "LocalSkin";
}
@Override
public int getPriority() {
return 710;
}
@Override
public String getSkinRoot() {
return "LocalSkin/skins/{USERNAME}.png";
}
@Override
public String getCapeRoot() {
return "LocalSkin/capes/{USERNAME}.png";
}
@Override
public String getElytraRoot() {
return "LocalSkin/elytras/{USERNAME}.png";
}
}
/**
* Get cape Profile¬
*
* @since 14.16
*/
public static LegacyLoader.DefaultProfile getCapeProfile(LegacyLoader loader, String name, String capeRoot, int priority) {
return new DefaultProfile(loader) {
@Override
public String getSkinRoot() {
return null;
}
@Override
public String getCapeRoot() {
return capeRoot;
}
@Override
public String getElytraRoot() {
return null;
}
@Override
public String getName() {
return name;
}
@Override
public int getPriority() {
return priority;
}
};
}
public static final String USERNAME_PLACEHOLDER = "{USERNAME}";
public static final String UUID_PLACEHOLDER = "{UUID}";
/**
* Mojang UUID with -
*
* @since 14.16
*/
public static final String STANDARD_UUID_PLACEHOLDER = "{STANDARD_UUID}";
@Override
public UserProfile loadProfile(SkinSiteProfile ssp, GameProfile gameProfile) {
UserProfile profile = new UserProfile();
//Try to load all textures
getTextureUrl(ssp, gameProfile, ssp.skin, it -> {
profile.skinUrl = it;
profile.model = ssp.model;
});
getTextureUrl(ssp, gameProfile, ssp.cape, it -> profile.capeUrl = it);
getTextureUrl(ssp, gameProfile, ssp.elytra, it -> profile.elytraUrl = it);
if (profile.isEmpty()) {
CustomSkinLoader.logger.info("No texture could be found.");
return null;
}
return profile;
}
private void getTextureUrl(
SkinSiteProfile ssp, GameProfile gameProfile, String baseUrl, Consumer<String> onSuccess) {
//Base URL is empty
if (baseUrl == null || baseUrl.isEmpty()) {
return;
}
String url = expandURL(baseUrl, gameProfile.getName());
//No texture can be loaded
if (url == null) {
return;
}
//Local texture file logic
if (HttpUtil0.isLocal(url)) {
File file = new File(CustomSkinLoader.DATA_DIR, url);
if (file.exists() && file.isFile()) {
String fakeUrl = HttpTextureUtil.getLocalLegacyFakeUrl(url,
HttpTextureUtil.getHash(url, file.length(), file.lastModified()));
onSuccess.accept(fakeUrl);
}
return;
}
//Remote texture logic
HttpRequestUtil.HttpResponce responce = HttpRequestUtil.makeHttpRequest(new HttpRequestUtil.HttpRequest(url)
.setUserAgent(ssp.userAgent).setCheckPNG(ssp.checkPNG != null && ssp.checkPNG).setLoadContent(false));
if (responce.success) {
onSuccess.accept(HttpTextureUtil.getLegacyFakeUrl(url));
}
}
@Override
public boolean compare(SkinSiteProfile ssp0, SkinSiteProfile ssp1) {
return Objects.equals(ssp0.skin, ssp1.skin) && Objects.equals(ssp0.cape, ssp1.cape) &&
Objects.equals(ssp0.elytra, ssp1.elytra);
}
@Override
public String getName() {
return "Legacy";
}
@Override
public void init(SkinSiteProfile ssp) {
initFolder(ssp.skin);
initFolder(ssp.cape);
initFolder(ssp.elytra);
}
@SuppressWarnings("ResultOfMethodCallIgnored")
private void initFolder(String target) {
//Only local skin should init folder
if (!HttpUtil0.isLocal(target)) {
return;
}
String file = target.replace(USERNAME_PLACEHOLDER, "init");
File folder = new File(CustomSkinLoader.DATA_DIR, file).getParentFile();
if (folder != null && !folder.exists()) {
folder.mkdirs();
}
}
private String expandURL(String url, String username) {
String t = url.replace(USERNAME_PLACEHOLDER, username);
if (!t.contains(UUID_PLACEHOLDER) && !t.contains(STANDARD_UUID_PLACEHOLDER)) {
return t;
}
String uuid = MojangAPILoader.getMojangUuidByUsername(username, true);
//If Mojang uuid not found, won't load the texture
if (uuid == null) {
return null;
}
String styledUuid = uuid.replace("-", "");
return t.replace(UUID_PLACEHOLDER, styledUuid).replace(STANDARD_UUID_PLACEHOLDER, uuid);
}
}
@@ -0,0 +1,232 @@
package customskinloader.loader;
import java.nio.charset.StandardCharsets;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
import com.google.common.collect.Iterables;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.mojang.authlib.GameProfile;
import com.mojang.authlib.minecraft.MinecraftProfileTexture;
import com.mojang.authlib.properties.Property;
import com.mojang.authlib.properties.PropertyMap;
import com.mojang.authlib.yggdrasil.response.MinecraftProfilePropertiesResponse;
import com.mojang.authlib.yggdrasil.response.MinecraftTexturesPayload;
import com.mojang.util.UUIDTypeAdapter;
import customskinloader.CustomSkinLoader;
import customskinloader.config.SkinSiteProfile;
import customskinloader.plugin.ICustomSkinLoaderPlugin;
import customskinloader.profile.ModelManager0;
import customskinloader.profile.UserProfile;
import customskinloader.utils.HttpRequestUtil;
import org.apache.commons.codec.binary.Base64;
import org.apache.commons.lang3.StringUtils;
public class MojangAPILoader implements ICustomSkinLoaderPlugin, ProfileLoader.IProfileLoader {
@Override
public ProfileLoader.IProfileLoader getProfileLoader() {
return this;
}
@Override
public List<IDefaultProfile> getDefaultProfiles() {
return Lists.newArrayList(new Mojang(this));
}
public abstract static class DefaultProfile implements ICustomSkinLoaderPlugin.IDefaultProfile {
protected final MojangAPILoader loader;
public DefaultProfile(MojangAPILoader loader) {
this.loader = loader;
}
@Override
public void updateSkinSiteProfile(SkinSiteProfile ssp) {
ssp.type = this.loader.getName();
ssp.apiRoot = this.getAPIRoot();
ssp.sessionRoot = this.getSessionRoot();
}
public abstract String getAPIRoot();
public abstract String getSessionRoot();
}
public static class Mojang extends MojangAPILoader.DefaultProfile {
public Mojang(MojangAPILoader loader) {
super(loader);
}
@Override
public String getName() {
return "Mojang";
}
@Override
public int getPriority() {
return 100;
}
@Override
public String getAPIRoot() {
return getMojangApiRoot();
}
@Override
public String getSessionRoot() {
return getMojangSessionRoot();
}
}
@Override
public UserProfile loadProfile(SkinSiteProfile ssp, GameProfile gameProfile) {
Map<MinecraftProfileTexture.Type, MinecraftProfileTexture> map = getTextures(gameProfile);
if (!map.isEmpty()) {
CustomSkinLoader.logger.info("Default profile will be used.");
return ModelManager0.toUserProfile(map);
}
String username = gameProfile.getName();
GameProfile newGameProfile = loadGameProfileCached(ssp.apiRoot, username);
if (newGameProfile == null) {
CustomSkinLoader.logger.info("Profile not found.(" + username + "'s profile not found.)");
return null;
}
newGameProfile = fillGameProfile(ssp.sessionRoot, newGameProfile);
map = getTextures(newGameProfile);
if (!map.isEmpty()) {
gameProfile.getProperties().putAll(newGameProfile.getProperties());
return ModelManager0.toUserProfile(map);
}
CustomSkinLoader.logger.info("Profile not found.(" + username + " doesn't have skin/cape.)");
return null;
}
private static final Map<String, GameProfile> gameProfileCache = new ConcurrentHashMap<>();
public static GameProfile loadGameProfileCached(String apiRoot, String username) {
return gameProfileCache.computeIfAbsent(apiRoot + " " + username,
ignored -> loadGameProfile(apiRoot, username));
}
//Username -> UUID
public static GameProfile loadGameProfile(String apiRoot, String username) {
//Doc (https://wiki.vg/Mojang_API#Playernames_-.3E_UUIDs)
Gson gson = new GsonBuilder().registerTypeAdapter(UUID.class, new UUIDTypeAdapter()).create();
HttpRequestUtil.HttpResponce responce = HttpRequestUtil.makeHttpRequest(
new HttpRequestUtil.HttpRequest(apiRoot + "profiles/minecraft")
.setCacheTime(600).setPayload(gson.toJson(Collections.singletonList(username)))
);
if (StringUtils.isEmpty(responce.content)) {
return null;
}
GameProfile[] profiles = gson.fromJson(responce.content, GameProfile[].class);
if (profiles.length == 0) {
return null;
}
GameProfile gameProfile = profiles[0];
if (gameProfile.getId() == null) {
return null;
}
return new GameProfile(gameProfile.getId(), gameProfile.getName());
}
/**
* Get Mojang UUID by username.
*
* @param username username to query
* @param standard if - in UUID
* @return UUID in Mojang API style string. Returns {@code null} if username not found in Mojang API.
*/
public static String getMojangUuidByUsername(String username, boolean standard) {
GameProfile profile = loadGameProfileCached(getMojangApiRoot(), username);
if (profile == null) {
return null;
}
UUID id = profile.getId();
return standard ? id.toString() : UUIDTypeAdapter.fromUUID(id);
}
//UUID -> Profile
public static GameProfile fillGameProfile(String sessionRoot, GameProfile profile) {
//Doc (http://wiki.vg/Mojang_API#UUID_-.3E_Profile_.2B_Skin.2FCape)
HttpRequestUtil.HttpResponce responce = HttpRequestUtil.makeHttpRequest(
new HttpRequestUtil.HttpRequest(sessionRoot + "session/minecraft/profile/"
+ UUIDTypeAdapter.fromUUID(profile.getId())).setCacheTime(90));
if (StringUtils.isEmpty(responce.content)) {
return profile;
}
Gson gson = new GsonBuilder()
.registerTypeAdapter(UUID.class, new UUIDTypeAdapter())
.registerTypeAdapter(PropertyMap.class, new PropertyMap.Serializer())
.create();
MinecraftProfilePropertiesResponse propertiesResponce = gson.fromJson(responce.content, MinecraftProfilePropertiesResponse.class);
GameProfile newGameProfile = new GameProfile(propertiesResponce.getId(), propertiesResponce.getName());
newGameProfile.getProperties().putAll(propertiesResponce.getProperties());
return newGameProfile;
}
public static Map<MinecraftProfileTexture.Type, MinecraftProfileTexture> getTextures(GameProfile gameProfile) {
if (gameProfile == null) {
return Maps.newHashMap();
}
Property textureProperty = Iterables.getFirst(gameProfile.getProperties().get("textures"), null);
if (textureProperty == null) {
return Maps.newHashMap();
}
String value = textureProperty.getValue();
if (StringUtils.isBlank(value)) {
return Maps.newHashMap();
}
String json = new String(Base64.decodeBase64(value), StandardCharsets.UTF_8);
Gson gson = new GsonBuilder().registerTypeAdapter(UUID.class, new UUIDTypeAdapter()).create();
MinecraftTexturesPayload result = gson.fromJson(json, MinecraftTexturesPayload.class);
if (result == null || result.getTextures() == null) {
return Maps.newHashMap();
}
return result.getTextures();
}
@Override
public boolean compare(SkinSiteProfile ssp0, SkinSiteProfile ssp1) {
return (!StringUtils.isNoneEmpty(ssp0.apiRoot) || ssp0.apiRoot.equalsIgnoreCase(ssp1.apiRoot)) ||
(!StringUtils.isNoneEmpty(ssp0.sessionRoot) || ssp0.sessionRoot.equalsIgnoreCase(ssp1.sessionRoot));
}
@Override
public String getName() {
return "MojangAPI";
}
@Override
public void init(SkinSiteProfile ssp) {
//Init default api & session root for Mojang API
if (ssp.apiRoot == null)
ssp.apiRoot = getMojangApiRoot();
if (ssp.sessionRoot == null)
ssp.sessionRoot = getMojangSessionRoot();
}
// Prevent authlib-injector (https://github.com/yushijinhun/authlib-injector) from modifying these strings
private static final String MOJANG_API_ROOT = "https://api{DO_NOT_MODIFY}.mojang.com/";
private static final String MOJANG_SESSION_ROOT = "https://sessionserver{DO_NOT_MODIFY}.mojang.com/";
public static String getMojangApiRoot() {
return MOJANG_API_ROOT.replace("{DO_NOT_MODIFY}", "");
}
public static String getMojangSessionRoot() {
return MOJANG_SESSION_ROOT.replace("{DO_NOT_MODIFY}", "");
}
}
@@ -0,0 +1,33 @@
package customskinloader.loader;
import java.util.HashMap;
import com.mojang.authlib.GameProfile;
import customskinloader.CustomSkinLoader;
import customskinloader.config.SkinSiteProfile;
import customskinloader.plugin.ICustomSkinLoaderPlugin;
import customskinloader.plugin.PluginLoader;
import customskinloader.profile.UserProfile;
public class ProfileLoader {
public static final HashMap<String, IProfileLoader> LOADERS = initLoaders();
private static HashMap<String, IProfileLoader> initLoaders() {
HashMap<String, ProfileLoader.IProfileLoader> profileLoaders = new HashMap<>();
for (ICustomSkinLoaderPlugin plugin : PluginLoader.PLUGINS) {
ProfileLoader.IProfileLoader profileLoader = plugin.getProfileLoader();
if (profileLoader != null) {
profileLoaders.put(profileLoader.getName().toLowerCase(), profileLoader);
CustomSkinLoader.logger.info("Add a profile loader: " + profileLoader.getName());
}
}
return profileLoaders;
}
public interface IProfileLoader {
UserProfile loadProfile(SkinSiteProfile ssp,GameProfile gameProfile) throws Exception;
boolean compare(SkinSiteProfile ssp0,SkinSiteProfile ssp1);
String getName();
void init(SkinSiteProfile ssp);
}
}
@@ -0,0 +1,144 @@
package customskinloader.loader.jsonapi;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import com.google.common.collect.Lists;
import customskinloader.CustomSkinLoader;
import customskinloader.loader.JsonAPILoader;
import customskinloader.plugin.ICustomSkinLoaderPlugin;
import customskinloader.profile.ModelManager0;
import customskinloader.profile.UserProfile;
import customskinloader.utils.HttpTextureUtil;
import org.apache.commons.lang3.StringUtils;
public class CustomSkinAPI implements JsonAPILoader.IJsonAPI {
public static class LittleSkin extends JsonAPILoader.DefaultProfile {
public LittleSkin(JsonAPILoader loader) {
super(loader);
}
@Override
public String getName() {
return "LittleSkin";
}
@Override
public int getPriority() {
return 200;
}
@Override
public String getRoot() {
return "https://littleskin.cn/csl/";
}
}
public static class BlessingSkin extends JsonAPILoader.DefaultProfile {
public BlessingSkin(JsonAPILoader loader) {
super(loader);
}
@Override
public String getName() {
return "BlessingSkin";
}
@Override
public int getPriority() {
return 300;
}
@Override
public String getRoot() {
return "https://skin.prinzeugen.net/";
}
}
// // OneSkin has been removed temporarily
// public static class OneSkin extends JsonAPILoader.DefaultProfile {
// public OneSkin(JsonAPILoader loader) { super(loader); }
// @Override public String getName() { return "OneSkin"; }
// @Override public int getPriority() { return 500; }
// @Override public String getRoot() { return "http://fleey.cn/skin/skin_user/skin_json.php/"; }
// }
private static final String TEXTURES = "textures/";
private static final String SUFFIX = ".json";
@Override
public List<ICustomSkinLoaderPlugin.IDefaultProfile> getDefaultProfiles(JsonAPILoader loader) {
return Lists.newArrayList(new LittleSkin(loader), new BlessingSkin(loader));
}
@Override
public String toJsonUrl(String root, String username) {
return root + username + SUFFIX;
}
@Override
public UserProfile toUserProfile(String root, String json, boolean local) {
CustomSkinAPIProfile profile = CustomSkinLoader.GSON.fromJson(json, CustomSkinAPIProfile.class);
UserProfile p = new UserProfile();
if (StringUtils.isNotBlank(profile.skin)) {
p.skinUrl = root + TEXTURES + profile.skin;
if (local)
p.skinUrl = HttpTextureUtil.getLocalFakeUrl(p.skinUrl);
}
if (StringUtils.isNotBlank(profile.cape)) {
p.capeUrl = root + TEXTURES + profile.cape;
if (local)
p.capeUrl = HttpTextureUtil.getLocalFakeUrl(p.capeUrl);
}
if (StringUtils.isNotBlank(profile.elytra)) {
p.elytraUrl = root + TEXTURES + profile.elytra;
if (local)
p.elytraUrl = HttpTextureUtil.getLocalFakeUrl(p.elytraUrl);
}
Map<String, String> textures = new LinkedHashMap<>();
if (profile.skins != null)
textures.putAll(profile.skins);
if (profile.textures != null)
textures.putAll(profile.textures);
if (textures.isEmpty())
return p;
boolean hasSkin = false;
for (String model : textures.keySet()) {
ModelManager0.Model enumModel = ModelManager0.getEnumModel(model);
if (enumModel == null || StringUtils.isEmpty(textures.get(model)))
continue;
if (ModelManager0.isSkin(enumModel))
if (hasSkin)
continue;
else
hasSkin = true;
String url = root + TEXTURES + textures.get(model);
if (local)
url = HttpTextureUtil.getLocalFakeUrl(url);
p.put(enumModel, url);
}
return p;
}
private static class CustomSkinAPIProfile {
public String username;
public LinkedHashMap<String, String> textures;
public LinkedHashMap<String, String> skins;
public String skin;
public String cape;
public String elytra;
}
@Override
public String getName() {
return "CustomSkinAPI";
}
}
@@ -0,0 +1,65 @@
package customskinloader.loader.jsonapi;
import java.io.File;
import java.util.List;
import java.util.UUID;
import com.google.common.collect.Lists;
import com.google.gson.Gson;
import customskinloader.CustomSkinLoader;
import customskinloader.config.SkinSiteProfile;
import customskinloader.loader.JsonAPILoader;
import customskinloader.plugin.ICustomSkinLoaderPlugin;
import customskinloader.utils.MinecraftUtil;
import org.apache.commons.io.FileUtils;
public class CustomSkinAPIPlus extends CustomSkinAPI {
private static String clientID=null;
public CustomSkinAPIPlus(){
File clientIDFile=new File(CustomSkinLoader.DATA_DIR,"CustomSkinAPIPlus-ClientID");
if(clientIDFile.isFile())
try{
clientID=FileUtils.readFileToString(clientIDFile, "UTF-8");
}catch(Exception e){
e.printStackTrace();
}
if(clientID==null){
clientID=UUID.randomUUID().toString();
try {
FileUtils.write(clientIDFile, clientID, "UTF-8");
} catch (Exception e) {
e.printStackTrace();
}
}
}
@Override
public List<ICustomSkinLoaderPlugin.IDefaultProfile> getDefaultProfiles(JsonAPILoader loader) {
return Lists.newArrayList();
}
@Override
public String getPayload(SkinSiteProfile ssp) {
return new Gson().toJson(new CustomSkinAPIPlusPayload());
}
@Override
public String getName() {
return "CustomSKinAPIPlus";
}
public static class CustomSkinAPIPlusPayload{
String gameVersion;//minecraft version
String modVersion;//mod version
String serverAddress;//ip:port
String clientID;//Minecraft Client ID
CustomSkinAPIPlusPayload(){
gameVersion = MinecraftUtil.getMinecraftMainVersion();
modVersion = CustomSkinLoader.CustomSkinLoader_VERSION;
serverAddress = MinecraftUtil.isLanServer() ? null : MinecraftUtil.getStandardServerAddress();
clientID = CustomSkinAPIPlus.clientID;
}
}
}
@@ -0,0 +1,80 @@
package customskinloader.loader.jsonapi;
import java.util.List;
import java.util.Map;
import com.google.common.collect.Lists;
import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import com.mojang.authlib.minecraft.MinecraftProfileTexture;
import customskinloader.loader.JsonAPILoader;
import customskinloader.plugin.ICustomSkinLoaderPlugin;
import customskinloader.profile.ModelManager0;
import customskinloader.profile.UserProfile;
public class ElyByAPI implements JsonAPILoader.IJsonAPI {
public static class ElyBy extends JsonAPILoader.DefaultProfile {
public ElyBy(JsonAPILoader loader) {
super(loader);
}
@Override
public String getName() {
return "ElyBy";
}
@Override
public int getPriority() {
return 400;
}
@Override
public String getRoot() {
return "http://skinsystem.ely.by/textures/";
}
}
public static class TLauncher extends JsonAPILoader.DefaultProfile {
public TLauncher(JsonAPILoader loader) {
super(loader);
}
@Override
public String getName() {
return "TLauncher";
}
@Override
public int getPriority() {
return 550;
}
@Override
public String getRoot() {
return "https://auth.tlauncher.org/skin/profile/texture/login/";
}
}
@Override
public List<ICustomSkinLoaderPlugin.IDefaultProfile> getDefaultProfiles(JsonAPILoader loader) {
return Lists.newArrayList(new ElyBy(loader), new TLauncher(loader));
}
@Override
public String toJsonUrl(String root, String username) {
return root + username;
}
@Override
public UserProfile toUserProfile(String root, String json, boolean local) {
Map<MinecraftProfileTexture.Type, MinecraftProfileTexture> result = new Gson().fromJson(json, new TypeToken<Map<MinecraftProfileTexture.Type, MinecraftProfileTexture>>() {
}.getType());
return ModelManager0.toUserProfile(result);
}
@Override
public String getName() {
return "ElyByAPI";
}
}
@@ -0,0 +1,64 @@
package customskinloader.loader.jsonapi;
import java.util.List;
import java.util.Map;
import com.google.common.collect.Lists;
import com.google.gson.Gson;
import com.mojang.authlib.minecraft.MinecraftProfileTexture;
import customskinloader.loader.JsonAPILoader;
import customskinloader.plugin.ICustomSkinLoaderPlugin;
import customskinloader.profile.ModelManager0;
import customskinloader.profile.UserProfile;
public class GlitchlessAPI implements JsonAPILoader.IJsonAPI {
public static class GlitchlessGames extends JsonAPILoader.DefaultProfile {
public GlitchlessGames(JsonAPILoader loader) {
super(loader);
}
@Override
public String getName() {
return "GlitchlessGames";
}
@Override
public int getPriority() {
return 700;
}
@Override
public String getRoot() {
return "https://games.glitchless.ru/api/minecraft/users/profiles/textures/?nickname=";
}
}
@Override
public List<ICustomSkinLoaderPlugin.IDefaultProfile> getDefaultProfiles(JsonAPILoader loader) {
return Lists.newArrayList(new GlitchlessGames(loader));
}
@Override
public String toJsonUrl(String root, String username) {
return root + username;
}
@Override
public UserProfile toUserProfile(String root, String json, boolean local) {
GlitchlessApiResponse result = new Gson().fromJson(json, GlitchlessApiResponse.class);
if (!result.textures.containsKey(MinecraftProfileTexture.Type.SKIN))
return null;
return ModelManager0.toUserProfile(result.textures);
}
@Override
public String getName() {
return "GlitchlessAPI";
}
public static class GlitchlessApiResponse {
protected Map<MinecraftProfileTexture.Type, MinecraftProfileTexture> textures;
}
}
@@ -0,0 +1,88 @@
package customskinloader.loader.jsonapi;
import com.google.common.collect.Lists;
import com.google.gson.Gson;
import customskinloader.config.SkinSiteProfile;
import customskinloader.loader.JsonAPILoader;
import customskinloader.loader.MojangAPILoader;
import customskinloader.plugin.ICustomSkinLoaderPlugin;
import customskinloader.profile.UserProfile;
import customskinloader.utils.TextureUtil;
import java.util.List;
public class MinecraftCapesAPI implements JsonAPILoader.IJsonAPI {
public static class MinecraftCapes extends JsonAPILoader.DefaultProfile {
public MinecraftCapes(JsonAPILoader loader) {
super(loader);
}
@Override
public String getName() {
return "MinecraftCapes";
}
@Override
public int getPriority() {
return 800;
}
@Override
public String getRoot() {
return "https://minecraftcapes.net/profile/";
}
}
@Override
public List<ICustomSkinLoaderPlugin.IDefaultProfile> getDefaultProfiles(JsonAPILoader loader) {
return Lists.newArrayList(new MinecraftCapes(loader));
}
@Override
public String toJsonUrl(String root, String username) {
String uuid = MojangAPILoader.getMojangUuidByUsername(username, false);
//If uuid cannot be found, we won't load profile in this API.
if (uuid == null) {
return null;
}
//API url is `${root}${uuid}`
return root + uuid;
}
@Override
public UserProfile toUserProfile(String root, String json, boolean local) {
MinecraftCapesApiResponse result = new Gson().fromJson(json, MinecraftCapesApiResponse.class);
if (result.textures == null || result.textures.cape == null) {
return null;
}
UserProfile profile = new UserProfile();
profile.capeUrl = TextureUtil.parseBase64Texture(result.textures.cape);
return profile;
}
@Override
public String getPayload(SkinSiteProfile ssp) {
return null;
}
@Override
public String getName() {
return "MinecraftCapesAPI";
}
public static class MinecraftCapesApiResponse {
public boolean animatedCape;
public boolean capeGlint;
public boolean upsideDown;
public MinecraftCapesApiTexture textures;
public static class MinecraftCapesApiTexture {
public String cape;
public String ears;
}
}
}
@@ -0,0 +1,105 @@
package customskinloader.loader.jsonapi;
import java.util.List;
import java.util.Map;
import com.google.common.collect.Lists;
import customskinloader.CustomSkinLoader;
import customskinloader.loader.JsonAPILoader;
import customskinloader.plugin.ICustomSkinLoaderPlugin;
import customskinloader.profile.ModelManager0;
import customskinloader.profile.UserProfile;
import customskinloader.utils.HttpTextureUtil;
import org.apache.commons.lang3.StringUtils;
public class UniSkinAPI implements JsonAPILoader.IJsonAPI {
public static class SkinMe extends JsonAPILoader.DefaultProfile {
public SkinMe(JsonAPILoader loader) {
super(loader);
}
@Override
public String getName() {
return "SkinMe";
}
@Override
public int getPriority() {
return 500;
}
@Override
public String getRoot() {
return "http://www.skinme.cc/uniskin/";
}
}
private static final String TEXTURES = "textures/";
private static final String SUFFIX = ".json";
@Override
public List<ICustomSkinLoaderPlugin.IDefaultProfile> getDefaultProfiles(JsonAPILoader loader) {
return Lists.newArrayList(new SkinMe(loader));
}
@Override
public String toJsonUrl(String root, String username) {
return root + username + SUFFIX;
}
@Override
public UserProfile toUserProfile(String root, String json, boolean local) {
UniSkinAPIProfile profile = CustomSkinLoader.GSON.fromJson(json, UniSkinAPIProfile.class);
UserProfile p = new UserProfile();
if (StringUtils.isNotBlank(profile.cape)) {
p.capeUrl = root + TEXTURES + profile.cape;
if (local)
p.capeUrl = HttpTextureUtil.getLocalFakeUrl(p.capeUrl);
}
if (profile.skins == null || profile.skins.isEmpty())
return p;
if (profile.model_preference == null || profile.model_preference.isEmpty())
return p;
boolean hasSkin = false;
for (String model : profile.model_preference) {
ModelManager0.Model enumModel = ModelManager0.getEnumModel(model);
if (enumModel == null || StringUtils.isEmpty(profile.skins.get(model)))
continue;
if (ModelManager0.isSkin(enumModel))
if (hasSkin)
continue;
else
hasSkin = true;
String url = root + TEXTURES + profile.skins.get(model);
if (local)
url = HttpTextureUtil.getLocalFakeUrl(url);
p.put(enumModel, url);
}
return p;
}
/**
* Json profile for UniSkinAPI
* <a href="https://github.com/RecursiveG/UniSkinMod/blob/master/src/main/java/org/devinprogress/uniskinmod/UniSkinApiProfile.java#L18-L22">Source Code</a>
*
* @author RecursiveG
*/
private static class UniSkinAPIProfile {
public String player_name;
public long last_update;
public List<String> model_preference;
public Map<String, String> skins;
public String cape;
}
@Override
public String getName() {
return "UniSkinAPI";
}
}
@@ -0,0 +1,110 @@
package customskinloader.loader.jsonapi;
import com.google.common.collect.Lists;
import com.google.gson.Gson;
import customskinloader.CustomSkinLoader;
import customskinloader.config.SkinSiteProfile;
import customskinloader.loader.JsonAPILoader;
import customskinloader.loader.MojangAPILoader;
import customskinloader.plugin.ICustomSkinLoaderPlugin;
import customskinloader.profile.UserProfile;
import customskinloader.utils.TextureUtil;
import java.util.List;
/**
* Wynntils cape API
* <a href="https://wynntils.com/">Home</a>
* Test player: Cael
*
* @since 14.16
*/
public class WynntilsAPI implements JsonAPILoader.IJsonAPI {
public static class Wynntils extends JsonAPILoader.DefaultProfile {
public Wynntils(JsonAPILoader loader) {
super(loader);
}
@Override
public String getName() {
return "Wynntils";
}
@Override
public int getPriority() {
return 820;
}
@Override
public String getRoot() {
return "https://athena.wynntils.com/user/getInfo";
}
}
@Override
public List<ICustomSkinLoaderPlugin.IDefaultProfile> getDefaultProfiles(JsonAPILoader loader) {
return Lists.newArrayList(new Wynntils(loader));
}
@Override
public String toJsonUrl(String root, String username) {
return root;
}
@Override
public UserProfile toUserProfile(String root, String json, boolean local) {
WynntilsApiResponse result = new Gson().fromJson(json, WynntilsApiResponse.class);
if (result.user == null || result.user.cosmetics == null || result.user.cosmetics.texture == null) {
return null;
}
UserProfile profile = new UserProfile();
String fakeUrl = TextureUtil.parseBase64Texture(result.user.cosmetics.texture);
if (result.user.cosmetics.hasCape) {
profile.capeUrl = fakeUrl;
} else if (result.user.cosmetics.hasElytra) {
profile.elytraUrl = fakeUrl;
} else {
CustomSkinLoader.logger.warning("Illegal response found in Wynntils");
return null;
}
return profile;
}
@Override
public String getPayload(SkinSiteProfile ssp, String username) {
WynntilsApiRequest req = new WynntilsApiRequest();
req.uuid = MojangAPILoader.getMojangUuidByUsername(username, true);
if (req.uuid == null) {
throw new JsonAPILoader.ProfileNotFoundException();
}
return new Gson().toJson(req);
}
@Override
public String getName() {
return "WynntilsAPI";
}
public static class WynntilsApiRequest {
public String uuid;
}
public static class WynntilsApiResponse {
public User user;
public static class User {
public String accountType;
public Cosmetics cosmetics;
public static class Cosmetics {
public boolean hasCape;
public boolean hasElytra;
public boolean hasEars;
public String texture;
}
}
}
}
@@ -0,0 +1,44 @@
package customskinloader.log;
import java.io.Writer;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardOpenOption;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
/**
* @since 14.16
*/
public class LogManager {
private static Path logFile;
private static Writer logWriter;
private static final Map<String, Logger> loggers = new ConcurrentHashMap<>();
public static void setLogFile(Path logFile) {
//Not updated
if (logFile == null || logFile.equals(LogManager.logFile)) {
return;
}
LogManager.logFile = logFile;
try {
//Close previous writer
if (logWriter != null) {
logWriter.close();
}
//Set new writer
Files.createDirectories(logFile.getParent());
logWriter = Files.newBufferedWriter(logFile, StandardCharsets.UTF_8, StandardOpenOption.CREATE);
loggers.forEach((k, v) -> v.setWriter(logWriter));
} catch (Exception e) {
e.printStackTrace();
}
}
public static Logger getLogger(String loggerName) {
return loggers.computeIfAbsent(loggerName,
it -> new Logger(logWriter, "CustomSkinLoader " + loggerName));
}
}
@@ -0,0 +1,185 @@
package customskinloader.log;
import javax.annotation.Nullable;
import java.io.*;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.text.SimpleDateFormat;
import java.util.Date;
/**
* the Logger
* Moved from <code>customskinloader.Logger</code>
*
* @since 14.16
*/
@SuppressWarnings("ResultOfMethodCallIgnored")
public class Logger {
private static final SimpleDateFormat DATE_FORMAT = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
/**
* A copy of <code>Config.enableLogStdOut</code>.
* Because <code>Config.loadConfig0()</code> will use <code>Logger.log()</code>,
* which means cannot access <code>CustomSkinLoader.config</code> here.
*
* @see customskinloader.config.Config#enableLogStdOut
* @since 14.15
*/
public boolean enableLogStdOut = false;
public enum Level {
DEBUG("DEBUG", false),
INFO("INFO", true),
WARNING("WARNING", true);
final String name;
final boolean display;
Level(String name, boolean display) {
this.name = name;
this.display = display;
}
public String getName() {
return name;
}
public boolean display() {
return display;
}
}
private Writer writer = null;
public void setWriter(Writer writer) {
this.writer = writer;
}
public Logger() {
//Logger isn't created.
}
public Logger(String logFile) {
this(new File(logFile));
}
public Logger(File logFile) {
this(logFile, "Unknown");
}
/**
* Create Logger with File
*
* @since 14.16
*/
public Logger(File logFile, String loggerName) {
this.loggerName = loggerName;
try {
if (!logFile.getParentFile().exists()) {
logFile.getParentFile().mkdirs();
}
if (!logFile.exists()) {
logFile.createNewFile();
}
writer = new BufferedWriter(new OutputStreamWriter(
Files.newOutputStream(logFile.toPath()), StandardCharsets.UTF_8));
System.out.println("Log Path: " + logFile.getAbsolutePath());
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* Create Logger with special Writer
*
* @since 14.16
*/
public Logger(@Nullable Writer writer, String loggerName) {
this.loggerName = loggerName;
this.writer = writer;
}
/**
* Logger name in log
*
* @since 14.16
*/
String loggerName;
public void close() {
if (writer != null) {
try {
writer.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
/**
* Judge if a level can be printed to standard output(System.out) with config.
*
* @param level log level
* @return true - print
*/
private boolean canPrintToStdOut(Level level) {
return level.display() && enableLogStdOut;
}
public void log(Level level, String msg) {
//When it neither be printed to standard output nor write to file
if (!canPrintToStdOut(level) && writer == null) {
return;
}
//Format, print and write
String sb = String.format("[%s] [%s/%s] [%s]: %s",
DATE_FORMAT.format(new Date()), Thread.currentThread().getName(), level.getName(), loggerName, msg);
if (canPrintToStdOut(level)) {
System.out.println(sb);
}
if (writer == null) {
return;
}
try {
String sb2 = String.format("%s\r\n", sb);
writer.write(sb2);//Writer.write has lock
writer.flush();
} catch (Exception e) {
e.printStackTrace();
}
}
public void debug(String msg) {
log(Level.DEBUG, msg);
}
public void debug(String format, Object... objs) {
debug(String.format(format, objs));
}
public void info(String msg) {
log(Level.INFO, msg);
}
public void info(String format, Object... objs) {
info(String.format(format, objs));
}
public void warning(String msg) {
log(Level.WARNING, msg);
}
public void warning(String format, Object... objs) {
warning(String.format(format, objs));
}
public void warning(Throwable e) {
StringWriter sw = new StringWriter();
e.printStackTrace(new PrintWriter(sw));
log(Level.WARNING, "Exception: " + sw);
}
}
@@ -0,0 +1,35 @@
package customskinloader.plugin;
import java.util.List;
import customskinloader.config.SkinSiteProfile;
import customskinloader.loader.ProfileLoader;
public interface ICustomSkinLoaderPlugin {
/**
* @return return a non-null value if need to add a new profile loader, otherwise return null.
*/
ProfileLoader.IProfileLoader getProfileLoader();
/**
* @return the default implementations which import by {@link ICustomSkinLoaderPlugin#getProfileLoader()}.
*/
List<IDefaultProfile> getDefaultProfiles();
interface IDefaultProfile {
/**
* @return the name of {@link SkinSiteProfile#name}.
*/
String getName();
/**
* @return the lower the number, the first to load.
*/
int getPriority();
/**
* Complete the {@link SkinSiteProfile} from config and write to config.
*/
void updateSkinSiteProfile(SkinSiteProfile ssp);
}
}
@@ -0,0 +1,55 @@
package customskinloader.plugin;
import java.io.File;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.ArrayList;
import java.util.ServiceLoader;
import com.google.common.collect.Lists;
import customskinloader.CustomSkinLoader;
import customskinloader.loader.JsonAPILoader;
import customskinloader.loader.LegacyLoader;
import customskinloader.loader.MojangAPILoader;
import customskinloader.loader.jsonapi.*;
import org.apache.commons.io.FileUtils;
public class PluginLoader {
public static final ICustomSkinLoaderPlugin[] DEFAULT_PLUGINS = new ICustomSkinLoaderPlugin[]{
new MojangAPILoader(),
new LegacyLoader(),
new JsonAPILoader(new CustomSkinAPI()),
new JsonAPILoader(new CustomSkinAPIPlus()),
new JsonAPILoader(new UniSkinAPI()),
new JsonAPILoader(new ElyByAPI()),
new JsonAPILoader(new GlitchlessAPI()),
new JsonAPILoader(new MinecraftCapesAPI()),
new JsonAPILoader(new WynntilsAPI()),
};
public static final ArrayList<ICustomSkinLoaderPlugin> PLUGINS = loadPlugins();
private static ArrayList<ICustomSkinLoaderPlugin> loadPlugins() {
File pluginsDir = new File(CustomSkinLoader.DATA_DIR, "Plugins");
ArrayList<URL> urls = new ArrayList<>();
if (!pluginsDir.isDirectory()) {
//noinspection ResultOfMethodCallIgnored
pluginsDir.mkdirs();
} else {
for (File plugin : FileUtils.listFiles(pluginsDir, new String[]{"jar", "zip"}, false)) {
try {
urls.add(plugin.toURI().toURL());
CustomSkinLoader.logger.info("Found a jar or zip file: " + plugin.getName());
} catch (MalformedURLException ignored) {
}
}
}
ArrayList<ICustomSkinLoaderPlugin> plugins = Lists.newArrayList(DEFAULT_PLUGINS);
ServiceLoader<ICustomSkinLoaderPlugin> sl = ServiceLoader.load(ICustomSkinLoaderPlugin.class, new URLClassLoader(urls.toArray(new URL[0]), PluginLoader.class.getClassLoader()));
for (ICustomSkinLoaderPlugin plugin : sl) {
plugins.add(plugin);
}
return plugins;
}
}
@@ -0,0 +1,160 @@
package customskinloader.profile;
import java.io.File;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import com.google.common.collect.Lists;
import org.apache.commons.codec.Charsets;
import org.apache.commons.codec.binary.Base64;
import org.apache.commons.io.FileUtils;
import org.apache.commons.io.FilenameUtils;
import org.apache.commons.lang3.StringUtils;
import com.google.common.collect.Iterables;
import com.google.common.collect.Maps;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.mojang.authlib.GameProfile;
import com.mojang.authlib.minecraft.MinecraftProfileTexture;
import com.mojang.authlib.minecraft.MinecraftProfileTexture.Type;
import com.mojang.authlib.properties.Property;
import com.mojang.util.UUIDTypeAdapter;
import customskinloader.CustomSkinLoader;
import customskinloader.utils.HttpRequestUtil;
import customskinloader.utils.HttpRequestUtil.HttpRequest;
import customskinloader.utils.HttpRequestUtil.HttpResponce;
import customskinloader.utils.HttpTextureUtil;
import customskinloader.utils.HttpUtil0;
public class DynamicSkullManager {
public static class SkullTexture{
public Map<Type,MinecraftProfileTexture> textures;
public String index;//Index File
public ArrayList<String> skins;
public int interval;
public boolean fromZero;
//For program
public long startTime;
public int period;
}
private Map<GameProfile, SkullTexture> dynamicTextures = new ConcurrentHashMap<>();
private Map<GameProfile, Map<Type, MinecraftProfileTexture>> staticTextures = new ConcurrentHashMap<>();
private List<GameProfile> loadingList=new ArrayList<GameProfile>();
private void parseGameProfile(GameProfile profile){
Property textureProperty = Iterables.getFirst(profile.getProperties().get("textures"), null);
if (textureProperty==null){
staticTextures.put(profile, Maps.<Type, MinecraftProfileTexture>newHashMap());
return;
}
String value=textureProperty.getValue();
if(StringUtils.isBlank(value)){
staticTextures.put(profile, Maps.<Type, MinecraftProfileTexture>newHashMap());
return;
}
@SuppressWarnings("deprecation") String json = new String(Base64.decodeBase64(value), Charsets.UTF_8);
Gson gson=new GsonBuilder().registerTypeAdapter(UUID.class,new UUIDTypeAdapter()).create();
SkullTexture result=gson.fromJson(json,SkullTexture.class);
if(result==null){
staticTextures.put(profile, Maps.<Type, MinecraftProfileTexture>newHashMap());
return;
}
staticTextures.put(profile, (result.textures==null || !result.textures.containsKey(Type.SKIN)) ?
Maps.<Type, MinecraftProfileTexture>newHashMap() : parseTextures(result.textures));
if(StringUtils.isNotEmpty(result.index)){
File indexFile=new File(CustomSkinLoader.DATA_DIR,result.index);
try{
String index=FileUtils.readFileToString(indexFile, "UTF-8");
if(StringUtils.isNotEmpty(index)){
String[] skins = CustomSkinLoader.GSON.fromJson(index, String[].class);
if(skins != null && skins.length != 0)
result.skins = Lists.newArrayList(skins);
}
}catch(Exception e){
CustomSkinLoader.logger.warning("Exception occurs while parsing index file: "+e.toString());
}
}
if(!CustomSkinLoader.config.enableDynamicSkull||result.skins==null||result.skins.isEmpty())
return;
CustomSkinLoader.logger.info("Try to load Dynamic Skull: "+json);
for(int i=0;i<result.skins.size();i++){//check and cache skins
String skin=result.skins.get(i);
if(HttpUtil0.isLocal(skin)){
//Local Skin
File skinFile=new File(CustomSkinLoader.DATA_DIR,skin);
if(skinFile.isFile()&&skinFile.length()>0){
//Skin found
String fakeUrl=HttpTextureUtil.getLocalFakeUrl(skin);
result.skins.set(i, fakeUrl);
}else{
//Could not find skin
result.skins.remove(i--);
}
}else{
//Online Skin
HttpResponce responce=HttpRequestUtil.makeHttpRequest(new HttpRequest(skin).setCacheFile(HttpTextureUtil.getCacheFile(FilenameUtils.getBaseName(skin))).setCacheTime(0).setLoadContent(false));
if(!responce.success){
//Could not load skin
result.skins.remove(i--);
}
}
}
if(result.skins.isEmpty()){//Nothing loaded
CustomSkinLoader.logger.info("Failed: Nothing loaded.");
return;
}
result.interval=Math.max(result.interval, 50);
if(result.fromZero)
result.startTime=System.currentTimeMillis();
result.period=result.interval*result.skins.size();
CustomSkinLoader.logger.info("Successfully loaded Dynamic Skull: "+new Gson().toJson(result));
dynamicTextures.put(profile, result);
staticTextures.remove(profile);
}
//Support local skin for skull
public Map<Type, MinecraftProfileTexture> parseTextures(Map<Type, MinecraftProfileTexture> textures) {
MinecraftProfileTexture skin=textures.get(Type.SKIN);
String skinUrl=skin.getUrl();
if(!HttpUtil0.isLocal(skinUrl))
return textures;
File skinFile=new File(CustomSkinLoader.DATA_DIR,skinUrl);
if(!skinFile.isFile())
return Maps.newHashMap();
textures.put(Type.SKIN, ModelManager0.getProfileTexture(HttpTextureUtil.getLocalFakeUrl(skinUrl), null));
return textures;
}
public Map<Type,MinecraftProfileTexture> getTexture(final GameProfile profile){
if(staticTextures.get(profile)!=null)
return staticTextures.get(profile);
if(loadingList.contains(profile))
return Maps.newHashMap();
if(dynamicTextures.containsKey(profile)){
SkullTexture texture=dynamicTextures.get(profile);
long time=System.currentTimeMillis()-texture.startTime;
int index=(int)Math.floor((time%texture.period)/texture.interval);
Map<Type,MinecraftProfileTexture> map=Maps.newHashMap();
map.put(Type.SKIN, ModelManager0.getProfileTexture(texture.skins.get(index), null));
return map;
}
loadingList.add(profile);
Thread loadThread=new Thread(){
public void run(){
parseGameProfile(profile);//Load in thread
loadingList.remove(profile);
}
};
loadThread.setName("Skull "+profile.hashCode());
loadThread.start();
return Maps.newHashMap();
}
}
@@ -0,0 +1,130 @@
package customskinloader.profile;
import java.util.HashMap;
import java.util.Map;
import com.google.common.collect.Maps;
import com.mojang.authlib.minecraft.MinecraftProfileTexture;
import customskinloader.fake.FakeMinecraftProfileTexture;
import org.apache.commons.lang3.StringUtils;
/**
* Model Manager for 1.8 and higher.
* A manager to check if model is available.
* It is the only class in package 'customskinloader' which has differences in different Minecraft version.
*
* @since 13.1
*/
public class ModelManager0 {
public enum Model {
SKIN_DEFAULT,
SKIN_SLIM,
CAPE,
ELYTRA
}
private static HashMap<String, Model> models = new HashMap<String, Model>();
private static MinecraftProfileTexture.Type typeElytra = null;
static {
for (MinecraftProfileTexture.Type type : MinecraftProfileTexture.Type.values()) {
if (type.ordinal() == 2)//ELYTRA
typeElytra = type;
}
models.put("default", Model.SKIN_DEFAULT);
models.put("slim", Model.SKIN_SLIM);
models.put("cape", Model.CAPE);
if (typeElytra != null) {
models.put("elytra", Model.ELYTRA);
models.put("elytron", Model.ELYTRA);
}
}
/**
* Get enum for the model.
*
* @param model - string model
* @since 14.5
*/
public static Model getEnumModel(String model) {
return models.get(model);
}
/**
* Check if model is skin.
*
* @since 14.5
*/
public static boolean isSkin(Model model) {
return model == Model.SKIN_DEFAULT || model == Model.SKIN_SLIM;
}
/**
* Check if elytra is supported.
*
* @since 14.5
*/
public static boolean isElytraSupported() {
return typeElytra != null;
}
/**
* Parse hashMapProfile to UserProfile
*
* @param profile - hashMapProfile (HashMap<String,MinecraftProfileTexture>)
* @return profile - UserProfile instance
* @since 13.1
*/
public static UserProfile toUserProfile(Map<MinecraftProfileTexture.Type, MinecraftProfileTexture> profile) {
UserProfile userProfile = new UserProfile();
if (profile == null)
return userProfile;
MinecraftProfileTexture skin = profile.get(MinecraftProfileTexture.Type.SKIN);
userProfile.skinUrl = skin == null ? null : skin.getUrl();//Avoid NullPointerException
userProfile.model = skin == null ? null : skin.getMetadata("model");
if (StringUtils.isEmpty(userProfile.model))
userProfile.model = "default";
MinecraftProfileTexture cape = profile.get(MinecraftProfileTexture.Type.CAPE);
userProfile.capeUrl = cape == null ? null : cape.getUrl();
return userProfile;
}
/**
* Parse UserProfile to hashMapProfile
*
* @param profile - UserProfile instance
* @return profile - hashMapProfile (HashMap<String,MinecraftProfileTexture>)
* @since 13.1
*/
public static Map<MinecraftProfileTexture.Type, MinecraftProfileTexture> fromUserProfile(UserProfile profile) {
Map<MinecraftProfileTexture.Type, MinecraftProfileTexture> map = Maps.newHashMap();
if (profile == null)
return map;
if (profile.skinUrl != null) {
Map<String, String> metadata = null;
if ("slim".equals(profile.model) || "auto".equals(profile.model)) {
metadata = Maps.newHashMap();
metadata.put("model", profile.model);
}
map.put(MinecraftProfileTexture.Type.SKIN, getProfileTexture(profile.skinUrl, metadata));
}
if (profile.capeUrl != null)
map.put(MinecraftProfileTexture.Type.CAPE, getProfileTexture(profile.capeUrl, null));
if (typeElytra != null && profile.elytraUrl != null)
map.put(typeElytra, getProfileTexture(profile.elytraUrl, null));
return map;
}
/**
* Parse url to MinecraftProfileTexture
*
* @param url - textureUrl
* @param metadata - metadata
* @return MinecraftProfileTexture
* @since 14.5
*/
public static MinecraftProfileTexture getProfileTexture(String url, Map<String, String> metadata) {
return new FakeMinecraftProfileTexture(url, metadata);
}
}
@@ -0,0 +1,126 @@
package customskinloader.profile;
import java.io.File;
import java.util.Deque;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentLinkedDeque;
import java.util.function.Consumer;
import com.mojang.authlib.minecraft.MinecraftProfileTexture;
import customskinloader.CustomSkinLoader;
import customskinloader.utils.TimeUtil;
import org.apache.commons.io.FileUtils;
public class ProfileCache {
public static File PROFILE_CACHE_DIR=new File(CustomSkinLoader.DATA_DIR,"ProfileCache");
private Map<String, CachedProfile> cachedProfiles = new ConcurrentHashMap<>();
private Map<String, UserProfile> localProfiles = new ConcurrentHashMap<>();
private Map<String, Deque<Consumer<Map<MinecraftProfileTexture.Type, MinecraftProfileTexture>>>> profileLoaders = new ConcurrentHashMap<>();
@SuppressWarnings("ResultOfMethodCallIgnored")
public ProfileCache(){
if(!PROFILE_CACHE_DIR.exists())
PROFILE_CACHE_DIR.mkdir();
}
public boolean isExist(String username){
return cachedProfiles.containsKey(username.toLowerCase());
}
public boolean isLoading(String username) {
CachedProfile cp=cachedProfiles.get(username.toLowerCase());
return cp != null && cp.loading;
}
public boolean isReady(String username){
CachedProfile cp=cachedProfiles.get(username.toLowerCase());
return cp != null && (cp.loading || cp.expiryTime > TimeUtil.getCurrentUnixTimestamp());
}
public boolean isExpired(String username){
CachedProfile cp=cachedProfiles.get(username.toLowerCase());
return cp == null || (cp.expiryTime <= TimeUtil.getCurrentUnixTimestamp());
}
public UserProfile getProfile(String username){
return getCachedProfile(username).profile;
}
public long getExpiry(String username){
return getCachedProfile(username).expiryTime;
}
public UserProfile getLocalProfile(String username){
if(localProfiles.containsKey(username.toLowerCase()))
return localProfiles.get(username.toLowerCase());
return loadLocalProfile(username);
}
public Optional<Consumer<Map<MinecraftProfileTexture.Type, MinecraftProfileTexture>>> getLastLoader(String username) {
Deque<Consumer<Map<MinecraftProfileTexture.Type, MinecraftProfileTexture>>> deque = this.profileLoaders.get(username);
if (deque != null) {
return Optional.ofNullable(deque.pollLast());
}
return Optional.empty();
}
public void setLoading(String username,boolean loading){
getCachedProfile(username).loading=loading;
}
public void updateCache(String username,UserProfile profile){
updateCache(username,profile,CustomSkinLoader.config.enableLocalProfileCache);
}
public void updateCache(String username,UserProfile profile,boolean saveLocalProfile){
CachedProfile cp=getCachedProfile(username);
cp.profile=profile;
cp.expiryTime=TimeUtil.getUnixTimestamp(CustomSkinLoader.config.cacheExpiry);
if(!saveLocalProfile)
return;
saveLocalProfile(username,profile);
}
public void putLoader(String username, Consumer<Map<MinecraftProfileTexture.Type, MinecraftProfileTexture>> loader) {
this.profileLoaders.putIfAbsent(username, new ConcurrentLinkedDeque<>());
this.profileLoaders.get(username).offerLast(loader);
}
private CachedProfile getCachedProfile(String username){
CachedProfile cp=cachedProfiles.get(username.toLowerCase());
if(cp!=null)
return cp;
cp=new CachedProfile();
cachedProfiles.put(username.toLowerCase(), cp);
return cp;
}
private UserProfile loadLocalProfile(String username){
File localProfile=new File(PROFILE_CACHE_DIR,username.toLowerCase()+".json");
if(!localProfile.exists()){
localProfiles.put(username.toLowerCase(), null);
}
try{
String json = FileUtils.readFileToString(localProfile, "UTF-8");
UserProfile profile=CustomSkinLoader.GSON.fromJson(json, UserProfile.class);
localProfiles.put(username.toLowerCase(), profile);
CustomSkinLoader.logger.info("Successfully load LocalProfile.");
return profile;
}catch(Exception e){
CustomSkinLoader.logger.info("Failed to load LocalProfile.("+e.toString()+")");
localProfiles.put(username.toLowerCase(), null);
}
return null;
}
@SuppressWarnings("ResultOfMethodCallIgnored")
private void saveLocalProfile(String username, UserProfile profile){
String json=CustomSkinLoader.GSON.toJson(profile);
File localProfile=new File(PROFILE_CACHE_DIR,username+".json");
if(localProfile.exists())
localProfile.delete();
try {
FileUtils.write(localProfile, json, "UTF-8");
CustomSkinLoader.logger.info("Successfully save LocalProfile.");
} catch (Exception e) {
CustomSkinLoader.logger.info("Failed to save LocalProfile.("+e.toString()+")");
}
}
}
class CachedProfile{
public UserProfile profile;
public long expiryTime=0;
public boolean loading=false;
}
@@ -0,0 +1,103 @@
package customskinloader.profile;
import org.apache.commons.lang3.StringUtils;
import customskinloader.profile.ModelManager0.Model;
/**The instance to storage user's profile in memory temporarily.
* In this manner, it could be easier to pass profile in program.
* @since 13.1
*/
public class UserProfile {
/**
* Direct url for skin.
* @since 13.1
*/
public String skinUrl=null;
/**
* Model for skin.
* default/slim
* @since 13.1
*/
public String model=null;
/**
* Direct url for cape.
* @since 13.1
*/
public String capeUrl=null;
/**
* Direct url for elytra.
* @since 14.5
*/
public String elytraUrl=null;
public void put(Model model,String url){
if(model==null||StringUtils.isEmpty(url))
return;
switch(model){
case SKIN_DEFAULT:
this.skinUrl=url;
this.model="default";
return;
case SKIN_SLIM:
this.skinUrl=url;
this.model="slim";
return;
case CAPE:
this.capeUrl=url;
return;
case ELYTRA:
this.elytraUrl = url;
}
}
/**
* Get parsed String to output the instance.
*/
@Override
public String toString(){
return toString(0);
}
public String toString(long expiry){
return "(SkinUrl: "+skinUrl+
" , Model: "+model+
" , CapeUrl: "+capeUrl+
(StringUtils.isBlank(elytraUrl)?" ":" , ElytraUrl: "+elytraUrl)+
(expiry==0?"":(" , Expiry: "+expiry))+")";
}
/**
* Check if the instance is empty.
* @return status (true - empty)
*/
public boolean isEmpty(){
return StringUtils.isEmpty(skinUrl) && StringUtils.isEmpty(capeUrl) && StringUtils.isEmpty(elytraUrl);
}
/**
* Check if the instance is full(Both skin and cape).
* @return status (true - full)
* @since 14.7
*/
public boolean isFull(){
return StringUtils.isNoneBlank(skinUrl,capeUrl);
}
public boolean hasSkinUrl(){
return StringUtils.isNotEmpty(skinUrl);
}
public void mix(UserProfile profile){
if(profile==null)
return;
if(StringUtils.isEmpty(this.skinUrl)) {
this.skinUrl = profile.skinUrl;
this.model = profile.model;
}
if(StringUtils.isEmpty(this.capeUrl))
this.capeUrl=profile.capeUrl;
if(StringUtils.isEmpty(this.elytraUrl))
this.elytraUrl=profile.elytraUrl;
}
}
@@ -0,0 +1,282 @@
package customskinloader.utils;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URI;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.zip.GZIPInputStream;
import org.apache.commons.codec.digest.DigestUtils;
import org.apache.commons.io.FileUtils;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.StringUtils;
import customskinloader.CustomSkinLoader;
public class HttpRequestUtil {
public static class HttpRequest {
public String url;
public String userAgent = null;
public String payload = null;
public boolean loadContent = true;
public boolean checkPNG = false;
/**
* Cache Time
* -1=No Cache 0=Always Cache t=Default Cache Time(second)
*/
public int cacheTime = 600;
public File cacheFile = null;//Default Cache File
public HttpRequest(String url) {
this.url = url;
}
public HttpRequest setUserAgent(String userAgent) {
this.userAgent = userAgent;
return this;
}
public HttpRequest setPayload(String payload) {
this.payload = payload;
return this;
}
public HttpRequest setLoadContent(boolean loadContent) {
this.loadContent = loadContent;
return this;
}
public HttpRequest setCheckPNG(boolean checkPNG) {
this.checkPNG = checkPNG;
return this;
}
public HttpRequest setCacheTime(int cacheTime) {
this.cacheTime = cacheTime;
return this;
}
public HttpRequest setCacheFile(File cacheFile) {
this.cacheFile = cacheFile;
return this;
}
}
public static class HttpResponce {
public String content = null;
public int responceCode = -1;
public boolean success = false;
public boolean fromCache = false;
}
public static class CacheInfo {
public String url;
public String etag = null;
public long lastModified = -1;//ms
public long expire = -1;//UNIX timestamp
}
public static final File CACHE_DIR = new File(CustomSkinLoader.DATA_DIR, "caches");
public static HttpResponce makeHttpRequest(HttpRequest request) {
return makeHttpRequest(request, 0);
}
public static HttpResponce makeHttpRequest(HttpRequest request, int redirectTime) {
try {
//No url provided, try to load from special cache file
if (request.url == null || request.url.isEmpty()) {
CustomSkinLoader.logger.debug("Try to read cache '" + request.cacheFile + "'.");
return loadFromCache(request, new HttpResponce());
}
CustomSkinLoader.logger.debug("Try to request '" + request.url + (request.userAgent == null ? "'." : "' with user agent '" + request.userAgent + "'."));
//Check Cache
if (StringUtils.isNotEmpty(request.payload) || CustomSkinLoader.config.forceDisableCache) {
request.cacheTime = -1;//No Cache
}
File cacheInfoFile = null;
CacheInfo cacheInfo = new CacheInfo();
if (request.cacheFile == null && request.cacheTime >= 0) {
String hash = DigestUtils.sha1Hex(request.url);
request.cacheFile = new File(CACHE_DIR, hash);
cacheInfoFile = new File(CACHE_DIR, hash + ".json");
}
//noinspection BulkFileAttributesRead
if (request.cacheTime == 0 && request.cacheFile.isFile()) {
return loadFromCache(request, new HttpResponce());
}
if (cacheInfoFile != null && cacheInfoFile.isFile()) {
String json = FileUtils.readFileToString(cacheInfoFile, "UTF-8");
if (StringUtils.isNotEmpty(json)) {
cacheInfo = CustomSkinLoader.GSON.fromJson(json, CacheInfo.class);
}
if (cacheInfo == null) {
cacheInfo = new CacheInfo();
}
if (cacheInfo.expire >= TimeUtil.getCurrentUnixTimestamp()) {
return loadFromCache(request, new HttpResponce(), cacheInfo.expire);
}
}
//Init Connection
URL rawUrl = new URL(request.url);
URI uri = new URI(
rawUrl.getProtocol(),
rawUrl.getUserInfo(),
rawUrl.getHost(),
rawUrl.getPort(),
rawUrl.getPath(),
rawUrl.getQuery(),
rawUrl.getRef()
);
String url = uri.toASCIIString();
if (!url.equalsIgnoreCase(request.url)) {
CustomSkinLoader.logger.debug("Encoded URL: " + url);
}
HttpURLConnection c = (HttpURLConnection) (new URL(url)).openConnection();
c.setReadTimeout(1000 * 10);
c.setConnectTimeout(1000 * 10);
c.setDoInput(true);
c.setUseCaches(false);
c.setInstanceFollowRedirects(true);
//Make Connection
if (cacheInfo.lastModified >= 0) {
c.setIfModifiedSince(cacheInfo.lastModified);
}
if (cacheInfo.etag != null) {
c.setRequestProperty("If-None-Match", cacheInfo.etag);
}
c.setRequestProperty("Accept-Encoding", "gzip");
if (request.userAgent != null) {
c.setRequestProperty("User-Agent", request.userAgent);
}
if (StringUtils.isNotEmpty(request.payload)) {
CustomSkinLoader.logger.info("Payload: " + request.payload);
c.setRequestMethod("POST");
c.setRequestProperty("Content-Type", "application/json");
c.setDoOutput(true);
OutputStream os = c.getOutputStream();
IOUtils.write(request.payload, os, "UTF-8");
IOUtils.closeQuietly(os);
}
c.connect();
//Check Connection
HttpResponce responce = new HttpResponce();
responce.responceCode = c.getResponseCode();
int res = c.getResponseCode();
if (res / 100 == 4 || res / 100 == 5) {//Failed
CustomSkinLoader.logger.debug("Failed to request (Response Code: " + res + ")");
return responce;
}
if (res == HttpURLConnection.HTTP_MOVED_PERM || res == HttpURLConnection.HTTP_MOVED_TEMP) {
//Redirect
if (redirectTime >= 4) {
CustomSkinLoader.logger.debug("Failed to request (Too many redirection)");
return responce;
}
request.url = c.getHeaderField("Location");//Get redirecting location
if (request.url == null) {
CustomSkinLoader.logger.debug("Failed to request (Redirecting location not found)");
return responce;
}
CustomSkinLoader.logger.debug("Redirect to: " + request.url);
return makeHttpRequest(request, redirectTime + 1);//Recursion
}
responce.success = true;
CustomSkinLoader.logger.debug("Successfully request (Response Code: " + res + " , Content Length: " + c.getContentLength() + ")");
if (responce.responceCode == HttpURLConnection.HTTP_NOT_MODIFIED) {
return loadFromCache(request, responce);
}
if (responce.responceCode == HttpURLConnection.HTTP_NO_CONTENT) {
request.cacheTime = 3600;
}
//Load Content
InputStream is = "gzip".equals(c.getContentEncoding()) ? new GZIPInputStream(c.getInputStream()) : c.getInputStream();
byte[] bytes = IOUtils.toByteArray(is);
if (request.checkPNG && (bytes.length <= 4 || bytes[1] != (byte) 'P' || bytes[2] != (byte) 'N' || bytes[3] != (byte) 'G')) {
CustomSkinLoader.logger.debug("Failed to request (Not Standard PNG)");
responce.success = false;
return responce;
}
if (request.cacheFile != null) {
FileUtils.writeByteArrayToFile(request.cacheFile, bytes);
if (cacheInfoFile != null) {
cacheInfo.url = request.url;
cacheInfo.etag = c.getHeaderField("ETag");
cacheInfo.lastModified = c.getLastModified();
cacheInfo.expire = getExpire(c, request.cacheTime);
FileUtils.write(cacheInfoFile, CustomSkinLoader.GSON.toJson(cacheInfo), "UTF-8");
}
//noinspection BulkFileAttributesRead
CustomSkinLoader.logger.debug("Saved to cache (Length: " + request.cacheFile.length() + " , Path: '" + request.cacheFile.getAbsolutePath() + "' , Expire: " + cacheInfo.expire + ")");
}
if (!request.loadContent) {
return responce;
}
responce.content = new String(bytes, StandardCharsets.UTF_8);
CustomSkinLoader.logger.debug("Content: " + responce.content);
return responce;
} catch (Exception e) {
CustomSkinLoader.logger.debug("Failed to request " + request.url + " (Exception: " + e + ")");
return loadFromCache(request, new HttpResponce());
}
}
public static File getCacheFile(String hash) {
return new File(CACHE_DIR, hash);
}
private static HttpResponce loadFromCache(HttpRequest request, HttpResponce responce) {
return loadFromCache(request, responce, 0);
}
private static HttpResponce loadFromCache(HttpRequest request, HttpResponce responce, long expireTime) {
if (request.cacheFile == null || !request.cacheFile.isFile()) {
return responce;
}
CustomSkinLoader.logger.debug("Cache file found (Length: " + request.cacheFile.length() + " , Path: '" + request.cacheFile.getAbsolutePath() + "' , Expire: " + expireTime + ")");
responce.fromCache = true;
responce.success = true;
if (!request.loadContent) {
return responce;
}
CustomSkinLoader.logger.info("Try to load from cache '" + request.cacheFile.getAbsolutePath() + "'.");
try {
responce.content = FileUtils.readFileToString(request.cacheFile, "UTF-8");
CustomSkinLoader.logger.debug("Successfully load from cache");
CustomSkinLoader.logger.debug("Content: " + responce.content);
} catch (IOException e) {
CustomSkinLoader.logger.debug("Failed to load from cache (Exception: " + e + ")");
responce.success = false;
}
return responce;
}
private final static Pattern MAX_AGE_PATTERN = Pattern.compile(".*?max-age=(\\d+).*?");
private static long getExpire(HttpURLConnection connection, int cacheTime) {
String cacheControl = connection.getHeaderField("Cache-Control");
if (StringUtils.isNotEmpty(cacheControl)) {
Matcher m = MAX_AGE_PATTERN.matcher(cacheControl);
if (m.matches())
return TimeUtil.getUnixTimestamp(Long.parseLong(m.group(m.groupCount())));
}
long expires = connection.getExpiration();
if (expires > 0)
return expires / 1000;
return TimeUtil.getUnixTimestampRandomDelay(cacheTime == 0 ? 2592000 : cacheTime);
}
}
@@ -0,0 +1,107 @@
package customskinloader.utils;
import java.io.File;
import org.apache.commons.codec.digest.DigestUtils;
import org.apache.commons.io.FilenameUtils;
import customskinloader.CustomSkinLoader;
public class HttpTextureUtil {
public static class HttpTextureInfo {
public String url = "";
public File cacheFile;
public String hash;
}
private static final String
LEGACY_MARK = "(LEGACY)",
LOCAL_MARK = "(LOCAL)",
LOCAL_LEGACY_MARK = "(LOCAL_LEGACY)",
BASE64_MARK = "(BASE64)";
public static File defaultCacheDir;
@SuppressWarnings("ResultOfMethodCallIgnored")
public static void cleanCacheDir() {
if (defaultCacheDir != null) {
defaultCacheDir.delete();
defaultCacheDir.mkdirs();
}
}
public static File getCacheDir() {
return defaultCacheDir == null ? new File(MinecraftUtil.getMinecraftDataDir(), "assets/skins") : defaultCacheDir;
}
public static HttpTextureInfo toHttpTextureInfo(String fakeUrl) {
HttpTextureInfo info = new HttpTextureInfo();
if (fakeUrl.startsWith("http")) {
info.url = fakeUrl;
info.hash = FilenameUtils.getBaseName(fakeUrl);
info.cacheFile = getCacheFile(info.hash);
return info;
}
if (fakeUrl.startsWith(LOCAL_LEGACY_MARK)) {
fakeUrl = fakeUrl.replace(LOCAL_LEGACY_MARK, "");
String[] t = fakeUrl.split(",", 2);
if (t.length != 2)
return info;
info.cacheFile = new File(CustomSkinLoader.DATA_DIR, t[1]);
info.hash = t[0];
return info;
}
if (fakeUrl.startsWith(LOCAL_MARK)) {
fakeUrl = fakeUrl.replace(LOCAL_MARK, "");
info.cacheFile = new File(CustomSkinLoader.DATA_DIR, fakeUrl);
info.hash = FilenameUtils.getBaseName(fakeUrl);
return info;
}
if (fakeUrl.startsWith(LEGACY_MARK)) {
fakeUrl = fakeUrl.replace(LEGACY_MARK, "");
info.url = fakeUrl;
info.hash = DigestUtils.sha1Hex(info.url);
info.cacheFile = HttpRequestUtil.getCacheFile(info.hash);
return info;
}
//Base64 fake url format: `(BASE64)${hash}`
if (fakeUrl.startsWith(BASE64_MARK)) {
fakeUrl = fakeUrl.replace(BASE64_MARK, "");
info.hash = fakeUrl;
info.cacheFile = getCacheFile(info.hash);
return info;
}
return info;
}
public static String getLegacyFakeUrl(String url) {
return LEGACY_MARK + url;
}
public static String getLocalFakeUrl(String path) {
return LOCAL_MARK + path;
}
public static String getLocalLegacyFakeUrl(String path, String hash) {
return LOCAL_LEGACY_MARK + hash + "," + path;
}
public static String getBase64FakeUrl(String hash) {
return BASE64_MARK + hash;
}
public static String getHash(String url, long size, long lastModified) {
return DigestUtils.sha1Hex(size + url + lastModified);
}
public static String getHash(byte[] bytes) {
return DigestUtils.sha256Hex(bytes);
}
public static File getCacheFile(String hash) {
return getCacheFile(defaultCacheDir, hash);
}
public static File getCacheFile(File cacheDir, String hash) {
return new File(new File(cacheDir, hash.length() > 2 ? hash.substring(0, 2) : "xx"), hash);
}
}
@@ -0,0 +1,127 @@
package customskinloader.utils;
import java.io.IOException;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;
import java.security.cert.X509Certificate;
import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSession;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
import org.apache.commons.lang3.StringUtils;
public class HttpUtil0 {
public static boolean isLocal(String url){
return url != null && !url.startsWith("http://") && !url.startsWith("https://");
}
//From: http://blog.csdn.net/xiyushiyi/article/details/46685387
public static void ignoreHttpsCertificate(){
HostnameVerifier doNotVerify = new HostnameVerifier() {
public boolean verify(String hostname, SSLSession session) {
return true;
}
};
TrustManager[] trustAllCerts = new TrustManager[] {new X509TrustManager() {
public X509Certificate[] getAcceptedIssuers() {
return new X509Certificate[] {};
}
public void checkClientTrusted(X509Certificate[] chain, String authType){}
public void checkServerTrusted(X509Certificate[] chain, String authType){}
}};
try {
SSLContext sc = SSLContext.getInstance("TLS");
sc.init(null, trustAllCerts, new java.security.SecureRandom());
//HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());
HttpsURLConnection.setDefaultSSLSocketFactory(new SSLSocketFactoryFacade());
HttpsURLConnection.setDefaultHostnameVerifier(doNotVerify);
} catch (Exception e) {
e.printStackTrace();
}
}
public static String parseAddress(String address) {
if(StringUtils.isEmpty(address))
return null;
String[] addresses=address.split(":");
InetAddress add;
try {
add = InetAddress.getByName(addresses[0]);
} catch (UnknownHostException e) {
e.printStackTrace();
return null;
}
return add.getHostAddress()+(addresses.length==2 ? addresses[1] : "25565");
}
public static boolean isLanServer(String standardAddress){
if(StringUtils.isEmpty(standardAddress))
return true;
String[] addresses=standardAddress.split(":");
int numIp=getNumIp(addresses[0]);
return numIp==0||numIp==getNumIp("127.0.0.1")||
(numIp>=getNumIp("192.168.0.0")&&numIp<=getNumIp("192.168.255.255"))||
(numIp>=getNumIp("10.0.0.0")&&numIp<=getNumIp("10.255.255.255"))||
(numIp>=getNumIp("172.16.0.0")&&numIp<=getNumIp("172.31.255.255"));
}
public static int getNumIp(String ip){
int num=0;
String[] ips=ip.split("\\.");
if(ips.length!=4)
return 0;
for(int i=0;i<4;i++)
num+=Integer.parseInt(ips[i])*(256^(3-i));
return num;
}
//https://stackoverflow.com/questions/30817934/extended-server-name-sni-extension-not-sent-with-jdk1-8-0-but-send-with-jdk1-7
public static class SSLSocketFactoryFacade extends SSLSocketFactory {
SSLSocketFactory sslsf;
public SSLSocketFactoryFacade() {
sslsf = (SSLSocketFactory) SSLSocketFactory.getDefault();;
}
@Override
public String[] getDefaultCipherSuites() {
return sslsf.getDefaultCipherSuites();
}
@Override
public String[] getSupportedCipherSuites() {
return sslsf.getSupportedCipherSuites();
}
@Override
public Socket createSocket(Socket socket, String s, int i, boolean b) throws IOException {
return sslsf.createSocket(socket, s, i, b);
}
@Override
public Socket createSocket(String s, int i) throws IOException, UnknownHostException {
return sslsf.createSocket(s, i);
}
@Override
public Socket createSocket(String s, int i, InetAddress inetAddress, int i1) throws IOException, UnknownHostException {
return sslsf.createSocket(s, i, inetAddress, i1);
}
@Override
public Socket createSocket(InetAddress inetAddress, int i) throws IOException {
return createSocket(inetAddress, i);
}
@Override
public Socket createSocket(InetAddress inetAddress, int i, InetAddress inetAddress1, int i1) throws IOException {
return createSocket(inetAddress, i, inetAddress1, i1);
}
}
}
@@ -0,0 +1,33 @@
package customskinloader.utils;
import java.io.File;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.LinkedList;
public class JavaUtil {
public static URL[] getClasspath() {
if (JavaUtil.class.getClassLoader() instanceof URLClassLoader) {
//Java 8-
//Use URLClassLoader Directly
URLClassLoader ucl = (URLClassLoader) JavaUtil.class.getClassLoader();
return ucl.getURLs();
} else {
//Java 9+
//It uses APPClassLoader instead of URLClassLoader
//Get Classpath from properties and parse it to URL array
String classpath = System.getProperty("java.class.path");
String[] elements = classpath.split(File.pathSeparator);
if (elements.length == 0)
return new URL[0];
LinkedList<URL> urls = new LinkedList<URL>();
for (String ele : elements) {
try {
urls.add(new File(ele).toURI().toURL());
} catch (Exception ignored) {
}
}
return urls.toArray(new URL[0]);
}
}
}
@@ -0,0 +1,91 @@
package customskinloader.utils;
import java.io.File;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.net.URL;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import com.mojang.authlib.GameProfile;
import net.minecraft.client.Minecraft;
import net.minecraft.client.multiplayer.ServerData;
import net.minecraft.client.renderer.texture.TextureManager;
import net.minecraft.client.resources.SkinManager;
/**
* @author Alexander Xia
* @since 13.6
*/
public class MinecraftUtil {
public static File getMinecraftDataDir() {
return Minecraft.getMinecraft().gameDir;
}
public static TextureManager getTextureManager() {
return Minecraft.getMinecraft().getTextureManager();
}
public static SkinManager getSkinManager() {
return Minecraft.getMinecraft().getSkinManager();
}
private static String minecraftMainVersion = null;
public static String getMinecraftMainVersion() {
//Check if cached version found
if (minecraftMainVersion != null) {
return minecraftMainVersion;
}
//version.json can be found in 1.14+
URL versionFile = MinecraftUtil.class.getResource("/version.json");
if (versionFile != null) {
try (
InputStream is = versionFile.openStream();
InputStreamReader isr = new InputStreamReader(is)
) {
JsonObject obj = new JsonParser().parse(isr).getAsJsonObject();
minecraftMainVersion = obj.get("name").getAsString();
return minecraftMainVersion;
} catch (Exception ignored) {
}
}
//RealmsSharedConstants.VERSION_STRING is available in 1.16-
try {
Class<?> realmsSharedConstants = Class.forName("net.minecraft.realms.RealmsSharedConstants");
MethodHandle mh = MethodHandles.publicLookup().findStaticGetter(realmsSharedConstants, "VERSION_STRING", String.class);
minecraftMainVersion = (String) mh.invoke();
return minecraftMainVersion;
} catch (Throwable ignored) {
}
//No version can be found
return "unknown";
}
// (domain|ip)(:port)
public static String getServerAddress() {
ServerData data = Minecraft.getMinecraft().getCurrentServerData();
if (data == null)//Single Player
return null;
return data.serverIP;
}
// ip:port
public static String getStandardServerAddress() {
return HttpUtil0.parseAddress(getServerAddress());
}
public static boolean isLanServer() {
return HttpUtil0.isLanServer(getStandardServerAddress());
}
public static String getCredential(GameProfile profile) {
return (profile == null || profile.hashCode() == 0) ? null :
(profile.getId() == null ? profile.getName() : String.format("%s-%s", profile.getName(), profile.getId()));
}
}
@@ -0,0 +1,33 @@
package customskinloader.utils;
import customskinloader.CustomSkinLoader;
import org.apache.commons.codec.binary.Base64;
import org.apache.commons.io.FileUtils;
import java.io.File;
public class TextureUtil {
/**
* Save and get fake url of base64 texture
*
* @param base64 texture in base64 string
* @return base64 fake url
* @since 14.16
*/
public static String parseBase64Texture(String base64) {
byte[] capeBytes = Base64.decodeBase64(base64);
String hash = HttpTextureUtil.getHash(capeBytes);
File cacheFile = HttpTextureUtil.getCacheFile(hash);
String fakeUrl = HttpTextureUtil.getBase64FakeUrl(hash);
//Save base64 image to cache file
try {
FileUtils.writeByteArrayToFile(cacheFile, capeBytes);
CustomSkinLoader.logger.info("Saved base64 image to " + cacheFile);
return fakeUrl;
} catch (Exception e) {
CustomSkinLoader.logger.warning("Error parsing base64 image: " + base64);
return null;
}
}
}
@@ -0,0 +1,17 @@
package customskinloader.utils;
public class TimeUtil {
public static long getCurrentUnixTimestamp(){
return System.currentTimeMillis() / 1000L;
}
public static long getUnixTimestamp(long offset){
return getCurrentUnixTimestamp()+offset;
}
public static long getUnixTimestampRandomDelay(long offset){
return getCurrentUnixTimestamp()+offset+random(0,5);
}
private static int random(int min,int max){
return (int)(Math.random()*(max-min+1))+min;
}
}
@@ -0,0 +1,50 @@
package customskinloader.utils;
import org.apache.commons.lang3.StringUtils;
public class Version implements Comparable {
private String version;
private int sub[];
public Version(String version) {
if (version == null) version = "";
this.version = version;
//Parse Subversion
String[] split = version.split("\\.");
sub = new int[split.length];
for (int i = 0; i < split.length; i++) {
if (StringUtils.isNumeric(split[i]))
sub[i] = Integer.parseInt(split[i]);
}
}
public static Version of(String version) {
return new Version(version);
}
public static int compare(String version, String anotherVersion) {
return Version.of(version).compareTo(anotherVersion);
}
@Override
public String toString() {
return version;
}
@Override
public int compareTo(Object o) {
if (o instanceof String) o = Version.of((String) o);//Parse String version
if (!(o instanceof Version)) throw new IllegalArgumentException(String.format("'%s' is not a Version.", o));
Version v = (Version) o;
int i = 0;
//Skip same subversion
while (i < sub.length && i < v.sub.length && sub[i] == v.sub[i]) i++;
//Compare first non-equal number
if (i < sub.length && i < v.sub.length)
return (sub[i] < v.sub[i]) ? -1 : ((sub[i] == v.sub[i]) ? 0 : 1); //Integer.compare(sub[i], v.sub[i]);
//Compare length if all subversion is same
return Integer.signum(sub.length - v.sub.length);
}
}
@@ -0,0 +1,18 @@
package net.minecraft.client.renderer;
import java.awt.image.BufferedImage;
import net.minecraft.client.renderer.texture.NativeImage;
public interface IImageBuffer extends Runnable {
BufferedImage parseUserSkin(BufferedImage image);
NativeImage func_195786_a(NativeImage image);
void skinAvailable();
@Override
default void run() {
this.skinAvailable();
}
}
@@ -0,0 +1,10 @@
package net.minecraft.client.renderer;
import net.minecraft.util.ResourceLocation;
public class RenderType {
// getEntityTranslucent
public static RenderType func_228644_e_(ResourceLocation locationIn) {
return null;
}
}
@@ -0,0 +1,63 @@
package net.minecraft.client.renderer.texture;
import java.io.InputStream;
/**
* Empty stack for NativeImage
*/
public class NativeImage {
public static NativeImage func_195713_a(InputStream inputStreamIn) {
return null;
}
public NativeImage(int p_i48122_1_, int p_i48122_2_, boolean p_i48122_3_) {
}
/**
* getWidth
*/
public int func_195702_a() {
return 0;
}
/**
* getHeight
*/
public int func_195714_b() {
return 0;
}
/**
* copyImage image
*/
public void func_195703_a(NativeImage p_195703_1_) {
}
/**
* fillAreaRGBA x0 y0 weight height rgba
*/
public void func_195715_a(int p_195715_1_, int p_195715_2_, int p_195715_3_, int p_195715_4_, int p_195715_5_) {
}
/**
* copyAreaRGBA x0 y0 dx dy weight height reversex reversey
*/
public void func_195699_a(int p_195699_1_, int p_195699_2_, int p_195699_3_, int p_195699_4_, int p_195699_5_, int p_195699_6_, boolean p_195699_7_, boolean p_195699_8_) {
}
/**
* getPixelRGBA x y
*/
public int func_195709_a(int p_195709_1_, int p_195709_2_) {
return 0;
}
/**
* setPixelRGBA x y rgba
*/
public void func_195700_a(int p_195700_1_, int p_195700_2_, int p_195700_3_) {
}
public void close() {
}
}
@@ -0,0 +1,5 @@
package net.minecraft.client.renderer.texture;
// exclude
public interface Texture {
}
@@ -0,0 +1,8 @@
package net.minecraft.client.resources;
import java.io.InputStream;
// this class shouldn't be created by ASM because of modlauncher issue.
public interface IResource {
InputStream getInputStream();
}
@@ -0,0 +1,10 @@
package net.minecraft.client.resources;
import java.io.IOException;
import net.minecraft.util.ResourceLocation;
// this class shouldn't be created by ASM because of modlauncher issue.
public interface IResourceManager {
IResource getResource(ResourceLocation location) throws IOException;
}
@@ -0,0 +1,6 @@
package net.minecraft.resources;
// exclude
public interface IResource {
}
@@ -0,0 +1,6 @@
package net.minecraft.resources;
// exclude
public interface IResourceManager {
}