PonyMirrors/MineLittlePony
1
0
Fork 0
mirror of https://github.com/MineLittlePony/MineLittlePony.git synced 2024-12-01 16:27:59 +01:00
Code Issues Projects Releases Packages Wiki Activity

Clean up GuiSkins and rewrite EntityPlayerModel to be less awful

Browse source
This commit is contained in:
Sollace 2018-07-15 12:23:27 +02:00
parent 02bc96d76c
commit 915c69b792
7 changed files with 398 additions and 390 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

118
src/hdskins/java/com/voxelmodpack/hdskins/LocalTexture.java Normal file
View file

@ -0,0 +1,118 @@
package com.voxelmodpack.hdskins;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import javax.imageio.ImageIO;
import com.mojang.authlib.GameProfile;
import com.mojang.authlib.minecraft.MinecraftProfileTexture.Type;
import net.minecraft.client.Minecraft;
import net.minecraft.client.renderer.texture.DynamicTexture;
import net.minecraft.client.renderer.texture.TextureManager;
import net.minecraft.client.resources.SkinManager.SkinAvailableCallback;
import net.minecraft.util.ResourceLocation;
public class LocalTexture {
private final TextureManager textureManager = Minecraft.getMinecraft().getTextureManager();
private DynamicTexture local;
private PreviewTexture remote;
private ResourceLocation remoteResource;
private ResourceLocation localResource;
private final IBlankSkinSupplier blank;
private final Type type;
public LocalTexture(GameProfile profile, Type type, IBlankSkinSupplier blank) {
this.blank = blank;
this.type = type;
String file = type.name().toLowerCase() + "s/preview_${profile.getName()}.png";
remoteResource = new ResourceLocation(file);
textureManager.deleteTexture(remoteResource);
reset();
}
public ResourceLocation getTexture() {
if (hasRemote()) {
return remoteResource;
}
return localResource;
}
public void reset() {
localResource = blank.getBlankSkin(type);
}
public boolean hasRemote() {
return remote != null;
}
public boolean hasLocal() {
return local != null;
}
public boolean usingLocal() {
return !hasRemote() && hasLocal();
}
public boolean uploadComplete() {
return hasRemote() && remote.isTextureUploaded();
}
public PreviewTexture getRemote() {
return remote;
}
public void setRemote(PreviewTextureManager ptm, SkinAvailableCallback callback) {
clearRemote();
remote = ptm.getPreviewTexture(remoteResource, type, blank.getBlankSkin(type), callback);
}
public void setLocal(File file) {
if (!file.exists()) {
return;
}
clearLocal();
try {
BufferedImage image = ImageIO.read(file);
BufferedImage bufferedImage = new ImageBufferDownloadHD().parseUserSkin(image);
local = new DynamicTextureImage(bufferedImage);
localResource = textureManager.getDynamicTextureLocation("localSkinPreview", local);
} catch (IOException e) {
e.printStackTrace();
}
}
private void clearRemote() {
if (hasRemote()) {
remote = null;
textureManager.deleteTexture(remoteResource);
}
}
public void clearLocal() {
if (hasLocal()) {
local = null;
textureManager.deleteTexture(localResource);
localResource = blank.getBlankSkin(type);
}
}
public interface IBlankSkinSupplier {
ResourceLocation getBlankSkin(Type type);
}
}

190
src/hdskins/java/com/voxelmodpack/hdskins/gui/EntityPlayerModel.java
View file

@ -4,171 +4,89 @@ import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Maps; import com.google.common.collect.Maps;
import com.mojang.authlib.GameProfile; import com.mojang.authlib.GameProfile;
import com.mojang.authlib.minecraft.MinecraftProfileTexture.Type; import com.mojang.authlib.minecraft.MinecraftProfileTexture.Type;
import com.voxelmodpack.hdskins.DynamicTextureImage;
import com.voxelmodpack.hdskins.HDSkinManager; import com.voxelmodpack.hdskins.HDSkinManager;
import com.voxelmodpack.hdskins.ImageBufferDownloadHD; import com.voxelmodpack.hdskins.LocalTexture;
import com.voxelmodpack.hdskins.PreviewTexture; import com.voxelmodpack.hdskins.LocalTexture.IBlankSkinSupplier;
import com.voxelmodpack.hdskins.PreviewTextureManager; import com.voxelmodpack.hdskins.PreviewTextureManager;
import net.minecraft.client.Minecraft; import net.minecraft.client.Minecraft;
import net.minecraft.client.renderer.texture.DynamicTexture;
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;
import net.minecraft.entity.EntityLivingBase; import net.minecraft.entity.EntityLivingBase;
import net.minecraft.inventory.EntityEquipmentSlot; import net.minecraft.inventory.EntityEquipmentSlot;
import net.minecraft.item.ItemStack; import net.minecraft.item.ItemStack;
import net.minecraft.util.EnumHand;
import net.minecraft.util.EnumHandSide; import net.minecraft.util.EnumHandSide;
import net.minecraft.util.ResourceLocation; import net.minecraft.util.ResourceLocation;
import java.awt.image.BufferedImage;
import java.io.File; import java.io.File;
import java.io.IOException;
import java.util.Map; import java.util.Map;
import javax.imageio.ImageIO;
@SuppressWarnings("EntityConstructor") import static net.minecraft.inventory.EntityEquipmentSlot.*;
public class EntityPlayerModel extends EntityLivingBase { import static net.minecraft.item.ItemStack.EMPTY;
import static com.mojang.authlib.minecraft.MinecraftProfileTexture.Type.*;
public class EntityPlayerModel extends EntityLivingBase implements IBlankSkinSupplier {
public static final ResourceLocation NO_SKIN = new ResourceLocation("hdskins", "textures/mob/noskin.png"); public static final ResourceLocation NO_SKIN = new ResourceLocation("hdskins", "textures/mob/noskin.png");
public static final ResourceLocation NO_ELYTRA = new ResourceLocation("textures/entity/elytra.png"); public static final ResourceLocation NO_ELYTRA = new ResourceLocation("textures/entity/elytra.png");
private Map<EntityEquipmentSlot, ItemStack> armors = Maps.newEnumMap(ImmutableMap.of( private final Map<EntityEquipmentSlot, ItemStack> armour = Maps.newEnumMap(ImmutableMap.of(
EntityEquipmentSlot.HEAD, ItemStack.EMPTY, HEAD, EMPTY,
EntityEquipmentSlot.CHEST, ItemStack.EMPTY, CHEST, EMPTY,
EntityEquipmentSlot.LEGS, ItemStack.EMPTY, LEGS, EMPTY,
EntityEquipmentSlot.FEET, ItemStack.EMPTY, FEET, EMPTY,
EntityEquipmentSlot.MAINHAND, ItemStack.EMPTY MAINHAND, EMPTY
)); ));
private PreviewTexture remoteSkinTexture; protected final LocalTexture skin;
private ResourceLocation remoteSkinResource; protected final LocalTexture elytra;
protected ResourceLocation localSkinResource;
private DynamicTexture localSkinTexture;
private PreviewTexture remoteElytraTexture;
private ResourceLocation remoteElytraResource;
private ResourceLocation localElytraResource;
private DynamicTexture localElytraTexture;
private TextureManager textureManager;
public final GameProfile profile; public final GameProfile profile;
protected boolean remoteSkin = false;
protected boolean hasLocalTexture = false;
protected boolean previewThinArms = false; protected boolean previewThinArms = false;
public EntityPlayerModel(GameProfile profile) { public EntityPlayerModel(GameProfile profile) {
super(new DummyWorld()); super(new DummyWorld());
this.profile = profile; this.profile = profile;
this.textureManager = Minecraft.getMinecraft().getTextureManager();
this.remoteSkinResource = new ResourceLocation("skins/preview_" + this.profile.getName() + ".png"); skin = new LocalTexture(profile, SKIN, this);
this.remoteElytraResource = new ResourceLocation("elytras/preview_" + this.profile.getName() + ".png"); elytra = new LocalTexture(profile, ELYTRA, this);
this.localSkinResource = getBlankSkin();
this.localElytraResource = getBlankElytra();
this.textureManager.deleteTexture(this.remoteSkinResource);
this.textureManager.deleteTexture(this.remoteElytraResource);
} }
public void reloadRemoteSkin(SkinManager.SkinAvailableCallback listener) { public void reloadRemoteSkin(SkinManager.SkinAvailableCallback listener) {
this.remoteSkin = true; PreviewTextureManager ptm = HDSkinManager.getPreviewTextureManager(profile);
if (this.remoteSkinTexture != null) {
this.textureManager.deleteTexture(this.remoteSkinResource);
}
if (this.remoteElytraTexture != null) {
this.textureManager.deleteTexture(this.remoteElytraResource);
}
PreviewTextureManager ptm = HDSkinManager.getPreviewTextureManager(this.profile);
this.remoteSkinTexture = ptm.getPreviewTexture(this.remoteSkinResource, Type.SKIN, getBlankSkin(), listener);
this.remoteElytraTexture = ptm.getPreviewTexture(this.remoteElytraResource, Type.ELYTRA, getBlankElytra(), null);
skin.setRemote(ptm, listener);
elytra.setRemote(ptm, listener);
} }
public void setLocalTexture(File skinTextureFile, Type type) { public void setLocalTexture(File skinTextureFile, Type type) {
if (skinTextureFile.exists()) { if (type == SKIN) {
if (type == Type.SKIN) { skin.setLocal(skinTextureFile);
this.remoteSkin = false; } else if (type == ELYTRA) {
if (this.localSkinTexture != null) { skin.setLocal(skinTextureFile);
this.textureManager.deleteTexture(this.localSkinResource);
this.localSkinTexture = null;
}
BufferedImage bufferedImage;
try {
BufferedImage image = ImageIO.read(skinTextureFile);
bufferedImage = new ImageBufferDownloadHD().parseUserSkin(image);
assert bufferedImage != null;
} catch (IOException var4) {
this.localSkinResource = getBlankSkin();
var4.printStackTrace();
return;
}
this.localSkinTexture = new DynamicTextureImage(bufferedImage);
this.localSkinResource = this.textureManager.getDynamicTextureLocation("localSkinPreview", this.localSkinTexture);
this.hasLocalTexture = true;
} else if (type == Type.ELYTRA) {
this.remoteSkin = false;
if (this.localElytraTexture != null) {
this.textureManager.deleteTexture(this.localElytraResource);
this.localElytraTexture = null;
}
BufferedImage bufferedImage;
try {
bufferedImage = ImageIO.read(skinTextureFile);
} catch (IOException var4) {
this.localElytraResource = getBlankElytra();
var4.printStackTrace();
return;
}
this.localElytraTexture = new DynamicTextureImage(bufferedImage);
this.localElytraResource = this.textureManager.getDynamicTextureLocation("localElytraPreview", this.localElytraTexture);
this.hasLocalTexture = true;
}
} }
} }
protected ResourceLocation getBlankSkin() { @Override
return NO_SKIN; public ResourceLocation getBlankSkin(Type type) {
} return type == SKIN ? NO_SKIN : NO_ELYTRA;
protected ResourceLocation getBlankElytra() {
return NO_ELYTRA;
} }
public boolean isUsingLocalTexture() { public boolean isUsingLocalTexture() {
return !this.remoteSkin && this.hasLocalTexture; return skin.usingLocal() || elytra.usingLocal();
} }
public boolean isTextureSetupComplete() { public boolean isTextureSetupComplete() {
return (this.remoteSkin && this.remoteSkinTexture != null) && this.remoteSkinTexture.isTextureUploaded(); return skin.uploadComplete() && elytra.uploadComplete();
} }
public void releaseTextures() { public void releaseTextures() {
if (this.localSkinTexture != null) { skin.clearLocal();
this.textureManager.deleteTexture(this.localSkinResource); elytra.clearLocal();
this.localSkinTexture = null;
this.localSkinResource = getBlankSkin();
this.hasLocalTexture = false;
}
if (this.localElytraTexture != null) {
this.textureManager.deleteTexture(this.localElytraResource);
this.localElytraTexture = null;
this.localElytraResource = getBlankElytra();
this.hasLocalTexture = false;
}
} }
public ResourceLocation getSkinTexture() { public LocalTexture getLocal(Type type) {
return this.remoteSkin ? (this.remoteSkinTexture != null ? this.remoteSkinResource return type == SKIN ? skin : elytra;
: DefaultPlayerSkin.getDefaultSkin(entityUniqueID)) : this.localSkinResource;
}
public ResourceLocation getElytraTexture() {
return this.remoteSkin && this.remoteElytraTexture != null ? this.remoteElytraResource : localElytraResource;
} }
public void setPreviewThinArms(boolean thinArms) { public void setPreviewThinArms(boolean thinArms) {
@ -176,37 +94,26 @@ public class EntityPlayerModel extends EntityLivingBase {
} }
public boolean usesThinSkin() { public boolean usesThinSkin() {
if (isTextureSetupComplete() && remoteSkinTexture.hasModel()) { if (skin.uploadComplete() && skin.getRemote().hasModel()) {
return remoteSkinTexture.usesThinArms(); return skin.getRemote().usesThinArms();
} }
return previewThinArms; return previewThinArms;
} }
@Override
public void swingArm(EnumHand hand) {
super.swingArm(hand);
if (!this.isSwingInProgress || this.swingProgressInt >= 4 || this.swingProgressInt < 0) {
this.swingProgressInt = -1;
this.isSwingInProgress = true;
this.swingingHand = hand;
}
}
public void updateModel() { public void updateModel() {
this.prevSwingProgress = this.swingProgress; prevSwingProgress = swingProgress;
if (this.isSwingInProgress) { if (isSwingInProgress) {
++this.swingProgressInt; ++swingProgressInt;
if (this.swingProgressInt >= 8) { if (swingProgressInt >= 8) {
this.swingProgressInt = 0; swingProgressInt = 0;
this.isSwingInProgress = false; isSwingInProgress = false;
} }
} else { } else {
this.swingProgressInt = 0; swingProgressInt = 0;
} }
this.swingProgress = this.swingProgressInt / 8.0F; swingProgress = swingProgressInt / 8F;
} }
@Override @Override
@ -216,17 +123,16 @@ public class EntityPlayerModel extends EntityLivingBase {
@Override @Override
public Iterable<ItemStack> getArmorInventoryList() { public Iterable<ItemStack> getArmorInventoryList() {
return armors.values(); return armour.values();
} }
@Override @Override
public ItemStack getItemStackFromSlot(EntityEquipmentSlot slotIn) { public ItemStack getItemStackFromSlot(EntityEquipmentSlot slotIn) {
return armors.get(slotIn); return armour.get(slotIn);
} }
@Override @Override
public void setItemStackToSlot(EntityEquipmentSlot slotIn, ItemStack stack) { public void setItemStackToSlot(EntityEquipmentSlot slotIn, ItemStack stack) {
armors.put(slotIn, stack); armour.put(slotIn, stack);
} }
} }

416
src/hdskins/java/com/voxelmodpack/hdskins/gui/GuiSkins.java
View file

@ -8,10 +8,10 @@ import com.google.common.base.Splitter;
import com.google.common.collect.ImmutableMap; import com.google.common.collect.ImmutableMap;
import com.mojang.authlib.GameProfile; import com.mojang.authlib.GameProfile;
import com.mojang.authlib.minecraft.MinecraftProfileTexture; import com.mojang.authlib.minecraft.MinecraftProfileTexture;
import com.mojang.authlib.minecraft.MinecraftProfileTexture.Type;
import com.mumfrey.liteloader.util.log.LiteLoaderLogger; import com.mumfrey.liteloader.util.log.LiteLoaderLogger;
import com.voxelmodpack.hdskins.HDSkinManager; import com.voxelmodpack.hdskins.HDSkinManager;
import com.voxelmodpack.hdskins.server.SkinServer; import com.voxelmodpack.hdskins.server.SkinServer;
import com.voxelmodpack.hdskins.server.SkinUploadResponse;
import com.voxelmodpack.hdskins.upload.FileDropListener; import com.voxelmodpack.hdskins.upload.FileDropListener;
import com.voxelmodpack.hdskins.upload.ThreadOpenFilePNG; import com.voxelmodpack.hdskins.upload.ThreadOpenFilePNG;
@ -28,8 +28,6 @@ import net.minecraft.inventory.EntityEquipmentSlot;
import net.minecraft.item.ItemStack; import net.minecraft.item.ItemStack;
import net.minecraft.util.EnumHand; import net.minecraft.util.EnumHand;
import net.minecraft.util.ResourceLocation; import net.minecraft.util.ResourceLocation;
import net.minecraft.util.Session;
import net.minecraft.util.text.TextFormatting;
import org.apache.commons.io.FilenameUtils; import org.apache.commons.io.FilenameUtils;
import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.LogManager;
import org.lwjgl.BufferUtils; import org.lwjgl.BufferUtils;
@ -72,16 +70,18 @@ public class GuiSkins extends GuiScreen {
private String uploadError; private String uploadError;
private volatile String skinMessage = I18n.format("hdskins.choose"); private volatile String skinMessage = I18n.format("hdskins.choose");
private String skinUploadMessage = I18n.format("hdskins.request"); private String skinUploadMessage = I18n.format("hdskins.request");
private volatile boolean fetchingSkin; private volatile boolean fetchingSkin;
private volatile boolean uploadingSkin; private volatile boolean uploadingSkin;
private volatile boolean pendingRemoteSkinRefresh; private volatile boolean pendingRemoteSkinRefresh;
private volatile boolean throttledByMojang; private volatile boolean throttledByMojang;
private int refreshCounter = -1; private int refreshCounter = -1;
private ThreadOpenFilePNG openFileThread; private ThreadOpenFilePNG openFileThread;
private final Object skinLock = new Object(); private final Object skinLock = new Object();
private File pendingSkinFile; private File pendingSkinFile;
private File selectedSkin; private File selectedSkin;
private float uploadOpacity = 0.0F; private float uploadOpacity = 0;
private int lastMouseX = 0; private int lastMouseX = 0;
@ -94,17 +94,16 @@ public class GuiSkins extends GuiScreen {
public GuiSkins() { public GuiSkins() {
Minecraft minecraft = Minecraft.getMinecraft(); Minecraft minecraft = Minecraft.getMinecraft();
// this.screenTitle = manager;
GameProfile profile = minecraft.getSession().getProfile(); GameProfile profile = minecraft.getSession().getProfile();
this.localPlayer = getModel(profile); localPlayer = getModel(profile);
this.remotePlayer = getModel(profile); remotePlayer = getModel(profile);
RenderManager rm = Minecraft.getMinecraft().getRenderManager(); RenderManager rm = Minecraft.getMinecraft().getRenderManager();
rm.renderEngine = minecraft.getTextureManager(); rm.renderEngine = minecraft.getTextureManager();
rm.options = minecraft.gameSettings; rm.options = minecraft.gameSettings;
rm.renderViewEntity = this.localPlayer; rm.renderViewEntity = localPlayer;
this.reloadRemoteSkin(); reloadRemoteSkin();
this.fetchingSkin = true; fetchingSkin = true;
instance = this; instance = this;
@ -128,40 +127,41 @@ public class GuiSkins extends GuiScreen {
} }
panorama.update(); panorama.update();
this.localPlayer.updateModel(); localPlayer.updateModel();
this.remotePlayer.updateModel(); remotePlayer.updateModel();
if (this.fetchingSkin && this.remotePlayer.isTextureSetupComplete()) {
this.fetchingSkin = false; if (fetchingSkin && remotePlayer.isTextureSetupComplete()) {
this.btnClear.enabled = true; fetchingSkin = false;
btnClear.enabled = true;
} }
synchronized (this.skinLock) { synchronized (skinLock) {
if (this.pendingSkinFile != null) { if (pendingSkinFile != null) {
System.out.println("Set " + textureType + " " + this.pendingSkinFile); System.out.println("Set " + textureType + " " + pendingSkinFile);
this.localPlayer.setLocalTexture(this.pendingSkinFile, textureType); localPlayer.setLocalTexture(pendingSkinFile, textureType);
this.selectedSkin = this.pendingSkinFile; selectedSkin = pendingSkinFile;
this.pendingSkinFile = null; pendingSkinFile = null;
this.onSetLocalSkin(textureType); onSetLocalSkin(textureType);
this.btnUpload.enabled = true; btnUpload.enabled = true;
} }
} }
if (this.pendingRemoteSkinRefresh) { if (pendingRemoteSkinRefresh) {
this.pendingRemoteSkinRefresh = false; pendingRemoteSkinRefresh = false;
this.fetchingSkin = true; fetchingSkin = true;
this.btnClear.enabled = false; btnClear.enabled = false;
this.reloadRemoteSkin(); reloadRemoteSkin();
} }
if (this.throttledByMojang) { if (throttledByMojang) {
if (this.refreshCounter == -1) { if (refreshCounter == -1) {
this.refreshCounter = 200; refreshCounter = 200;
} else if (this.refreshCounter > 0) { } else if (refreshCounter > 0) {
--this.refreshCounter; --refreshCounter;
} else { } else {
this.refreshCounter = -1; refreshCounter = -1;
this.throttledByMojang = false; throttledByMojang = false;
this.reloadRemoteSkin(); reloadRemoteSkin();
} }
} }
@ -175,10 +175,10 @@ public class GuiSkins extends GuiScreen {
private void reloadRemoteSkin() { private void reloadRemoteSkin() {
try { try {
this.remotePlayer.reloadRemoteSkin(this::onSetRemoteSkin); remotePlayer.reloadRemoteSkin(this::onSetRemoteSkin);
} catch (Exception var2) { } catch (Exception var2) {
var2.printStackTrace(); var2.printStackTrace();
this.throttledByMojang = true; throttledByMojang = true;
} }
} }
@ -189,28 +189,29 @@ public class GuiSkins extends GuiScreen {
panorama.init(); panorama.init();
this.buttonList.clear(); buttonList.clear();
this.buttonList.add(this.btnBrowse = new GuiButton(0, 30, this.height - 36, 60, 20, "Browse...")); buttonList.add(btnBrowse = new GuiButton(0, 30, height - 36, 60, 20, "Browse..."));
this.buttonList.add(this.btnUpload = new GuiButton(1, this.width / 2 - 24, this.height / 2 - 10, 48, 20, ">>")); buttonList.add(btnUpload = new GuiButton(1, width / 2 - 24, height / 2 - 10, 48, 20, ">>"));
this.buttonList.add(this.btnClear = new GuiButton(2, this.width - 90, this.height - 36, 60, 20, "Clear")); buttonList.add(btnClear = new GuiButton(2, width - 90, height - 36, 60, 20, "Clear"));
this.buttonList.add(this.btnBack = new GuiButton(3, this.width / 2 - 50, this.height - 36, 100, 20, "Close")); buttonList.add(btnBack = new GuiButton(3, width / 2 - 50, height - 36, 100, 20, "Close"));
ItemStack skin = new ItemStack(Items.LEATHER_LEGGINGS); ItemStack skin = new ItemStack(Items.LEATHER_LEGGINGS);
Items.LEATHER_LEGGINGS.setColor(skin, 0x3c5dcb); Items.LEATHER_LEGGINGS.setColor(skin, 0x3c5dcb);
this.buttonList.add(this.btnModeSkin = new GuiItemStackButton(4, 2, 2, skin)); buttonList.add(btnModeSkin = new GuiItemStackButton(4, 2, 2, skin));
skin = new ItemStack(Items.LEATHER_LEGGINGS); skin = new ItemStack(Items.LEATHER_LEGGINGS);
Items.LEATHER_LEGGINGS.setColor(skin, 0xfff500); Items.LEATHER_LEGGINGS.setColor(skin, 0xfff500);
this.buttonList.add(this.btnModeElytra = new GuiItemStackButton(5, 2, 52, new ItemStack(Items.ELYTRA))); buttonList.add(btnModeElytra = new GuiItemStackButton(5, 2, 52, new ItemStack(Items.ELYTRA)));
this.buttonList.add(this.btnModeSkinnySkin = new GuiItemStackButton(6, 2, 21, skin));
this.buttonList.add(this.btnAbout = new GuiButton(-1, this.width - 25, this.height - 25, 20, 20, "?")); buttonList.add(btnModeSkinnySkin = new GuiItemStackButton(6, 2, 21, skin));
buttonList.add(btnAbout = new GuiButton(-1, width - 25, height - 25, 20, 20, "?"));
this.btnUpload.enabled = false; btnUpload.enabled = false;
this.btnBrowse.enabled = !this.mc.isFullScreen(); btnBrowse.enabled = !mc.isFullScreen();
this.btnModeSkin.enabled = this.thinArmType; btnModeSkin.enabled = thinArmType;
this.btnModeSkinnySkin.enabled = !this.thinArmType; btnModeSkinnySkin.enabled = !thinArmType;
this.btnModeElytra.enabled = this.textureType == SKIN; btnModeElytra.enabled = textureType == SKIN;
} }
@ -231,107 +232,99 @@ public class GuiSkins extends GuiScreen {
} }
private void onFileOpenDialogClosed(JFileChooser fileDialog, int dialogResult) { private void onFileOpenDialogClosed(JFileChooser fileDialog, int dialogResult) {
this.openFileThread = null; openFileThread = null;
this.btnBrowse.enabled = true; btnBrowse.enabled = true;
if (dialogResult == 0) { if (dialogResult == 0) {
this.loadLocalFile(fileDialog.getSelectedFile()); loadLocalFile(fileDialog.getSelectedFile());
} }
} }
private void loadLocalFile(File skinFile) { private void loadLocalFile(File skinFile) {
Minecraft.getMinecraft().addScheduledTask(localPlayer::releaseTextures); Minecraft.getMinecraft().addScheduledTask(localPlayer::releaseTextures);
if (!skinFile.exists()) {
this.skinMessage = I18n.format("hdskins.error.unreadable");
} else if (!FilenameUtils.isExtension(skinFile.getName(), new String[]{"png", "PNG"})) {
this.skinMessage = I18n.format("hdskins.error.ext");
} else {
BufferedImage chosenImage;
try {
chosenImage = ImageIO.read(skinFile);
} catch (IOException var6) {
this.skinMessage = I18n.format("hdskins.error.open");
var6.printStackTrace();
return;
}
if (chosenImage == null) { if (!skinFile.exists()) {
this.skinMessage = I18n.format("hdskins.error.open"); skinMessage = I18n.format("hdskins.error.unreadable");
} else if (isPowerOfTwo(chosenImage.getWidth()) } else if (!FilenameUtils.isExtension(skinFile.getName(), new String[]{"png", "PNG"})) {
&& (chosenImage.getWidth() == chosenImage.getHeight() * 2 skinMessage = I18n.format("hdskins.error.ext");
|| chosenImage.getWidth() == chosenImage.getHeight()) } else {
&& chosenImage.getWidth() <= MAX_SKIN_DIMENSION try {
&& chosenImage.getHeight() <= MAX_SKIN_DIMENSION) { BufferedImage chosenImage = ImageIO.read(skinFile);
synchronized (this.skinLock) {
this.pendingSkinFile = skinFile; if (chosenImage == null) {
skinMessage = I18n.format("hdskins.error.open");
} else if (!acceptsSkinDimensions(chosenImage.getWidth(), chosenImage.getHeight())) {
skinMessage = I18n.format("hdskins.error.invalid");
} else {
synchronized (skinLock) {
pendingSkinFile = skinFile;
}
} }
} else { } catch (IOException var6) {
this.skinMessage = I18n.format("hdskins.error.invalid"); skinMessage = I18n.format("hdskins.error.open");
var6.printStackTrace();
} }
} }
} }
protected boolean acceptsSkinDimensions(int w, int h) {
return isPowerOfTwo(w) && w == h * 2 || w == h && w <= MAX_SKIN_DIMENSION && h <= MAX_SKIN_DIMENSION;
}
@Override @Override
protected void actionPerformed(GuiButton guiButton) { protected void actionPerformed(GuiButton guiButton) {
if (this.openFileThread == null && !this.uploadingSkin) { if (openFileThread == null && !uploadingSkin) {
if (this.uploadError != null) { if (uploadError != null) {
this.uploadError = null; uploadError = null;
} else { } else {
if (guiButton.id == this.btnBrowse.id) { if (guiButton.id == btnBrowse.id) {
this.selectedSkin = null; selectedSkin = null;
this.localPlayer.releaseTextures(); localPlayer.releaseTextures();
this.openFileThread = new ThreadOpenFilePNG(this.mc, I18n.format("hdskins.open.title"), this::onFileOpenDialogClosed); openFileThread = new ThreadOpenFilePNG(mc, I18n.format("hdskins.open.title"), this::onFileOpenDialogClosed);
this.openFileThread.start(); openFileThread.start();
guiButton.enabled = false; guiButton.enabled = false;
} } else if (guiButton.id == btnUpload.id) {
if (selectedSkin != null) {
if (guiButton.id == this.btnUpload.id) {
if (this.selectedSkin != null) {
punchServer("hdskins.upload", selectedSkin.toURI()); punchServer("hdskins.upload", selectedSkin.toURI());
this.btnUpload.enabled = false; btnUpload.enabled = false;
} else { } else {
this.setUploadError(I18n.format("hdskins.error.select")); setUploadError(I18n.format("hdskins.error.select"));
} }
} } else if (guiButton.id == btnClear.id && remotePlayer.isTextureSetupComplete()) {
if (guiButton.id == this.btnClear.id && this.remotePlayer.isTextureSetupComplete()) {
punchServer("hdskins.request", null); punchServer("hdskins.request", null);
this.btnUpload.enabled = this.selectedSkin != null; btnUpload.enabled = selectedSkin != null;
} } else if (guiButton.id == btnBack.id) {
mc.displayGuiScreen(new GuiMainMenu());
if (guiButton.id == this.btnBack.id) { } else if (guiButton.id == btnModeSkin.id || guiButton.id == btnModeElytra.id || guiButton.id == btnModeSkinnySkin.id) {
this.mc.displayGuiScreen(new GuiMainMenu());
}
if (guiButton.id == this.btnModeSkin.id || guiButton.id == this.btnModeElytra.id || guiButton.id == this.btnModeSkinnySkin.id) {
ItemStack stack; ItemStack stack;
if (guiButton.id == this.btnModeSkin.id) {
this.thinArmType = false; if (guiButton.id == btnModeSkin.id) {
this.textureType = SKIN; thinArmType = false;
textureType = SKIN;
stack = ItemStack.EMPTY; stack = ItemStack.EMPTY;
} else if (guiButton.id == this.btnModeSkinnySkin.id) { } else if (guiButton.id == btnModeSkinnySkin.id) {
this.thinArmType = true; thinArmType = true;
this.textureType = SKIN; textureType = SKIN;
stack = ItemStack.EMPTY; stack = ItemStack.EMPTY;
} else { } else {
this.textureType = ELYTRA; textureType = ELYTRA;
stack = new ItemStack(Items.ELYTRA); stack = new ItemStack(Items.ELYTRA);
} }
this.btnModeSkin.enabled = thinArmType; btnModeSkin.enabled = thinArmType;
this.btnModeSkinnySkin.enabled = !thinArmType; btnModeSkinnySkin.enabled = !thinArmType;
this.btnModeElytra.enabled = this.textureType == SKIN; btnModeElytra.enabled = textureType == SKIN;
guiButton.enabled = false; guiButton.enabled = false;
// clear currently selected skin // clear currently selected skin
this.selectedSkin = null; selectedSkin = null;
this.localPlayer.releaseTextures(); localPlayer.releaseTextures();
// put on or take off the elytra // put on or take off the elytra
this.localPlayer.setItemStackToSlot(EntityEquipmentSlot.CHEST, stack); localPlayer.setItemStackToSlot(EntityEquipmentSlot.CHEST, stack);
this.remotePlayer.setItemStackToSlot(EntityEquipmentSlot.CHEST, stack); remotePlayer.setItemStackToSlot(EntityEquipmentSlot.CHEST, stack);
this.localPlayer.setPreviewThinArms(thinArmType); localPlayer.setPreviewThinArms(thinArmType);
this.remotePlayer.setPreviewThinArms(thinArmType); remotePlayer.setPreviewThinArms(thinArmType);
} }
} }
@ -340,17 +333,17 @@ public class GuiSkins extends GuiScreen {
@Override @Override
protected void mouseClicked(int mouseX, int mouseY, int button) throws IOException { protected void mouseClicked(int mouseX, int mouseY, int button) throws IOException {
if (this.uploadError != null) { if (uploadError != null) {
this.uploadError = null; uploadError = null;
} else { } else {
super.mouseClicked(mouseX, mouseY, button); super.mouseClicked(mouseX, mouseY, button);
int bottom = this.height - 40; int bottom = height - 40;
int mid = this.width / 2; int mid = width / 2;
if ((mouseX > 30 && mouseX < mid - 30 || mouseX > mid + 30 && mouseX < this.width - 30) && mouseY > 30 && mouseY < bottom) { if ((mouseX > 30 && mouseX < mid - 30 || mouseX > mid + 30 && mouseX < width - 30) && mouseY > 30 && mouseY < bottom) {
this.localPlayer.swingArm(EnumHand.MAIN_HAND); localPlayer.swingArm(EnumHand.MAIN_HAND);
this.remotePlayer.swingArm(EnumHand.MAIN_HAND); remotePlayer.swingArm(EnumHand.MAIN_HAND);
} }
} }
@ -365,7 +358,7 @@ public class GuiSkins extends GuiScreen {
@Override @Override
protected void keyTyped(char keyChar, int keyCode) throws IOException { protected void keyTyped(char keyChar, int keyCode) throws IOException {
if (this.openFileThread == null && !this.uploadingSkin) { if (openFileThread == null && !uploadingSkin) {
if (keyCode == Keyboard.KEY_LEFT) { if (keyCode == Keyboard.KEY_LEFT) {
updateCounter -= 5; updateCounter -= 5;
@ -392,7 +385,7 @@ public class GuiSkins extends GuiScreen {
Gui.drawRect(mid + 30, 30, width - 30, bottom, Integer.MIN_VALUE); Gui.drawRect(mid + 30, 30, width - 30, bottom, Integer.MIN_VALUE);
drawGradientRect(30, horizon, mid - 30, bottom, 0x80FFFFFF, 0xffffff); drawGradientRect(30, horizon, mid - 30, bottom, 0x80FFFFFF, 0xffffff);
drawGradientRect(mid + 30, horizon, this.width - 30, bottom, 0x80FFFFFF, 0xffffff); drawGradientRect(mid + 30, horizon, width - 30, bottom, 0x80FFFFFF, 0xffffff);
super.drawScreen(mouseX, mouseY, partialTick); super.drawScreen(mouseX, mouseY, partialTick);
@ -400,22 +393,22 @@ public class GuiSkins extends GuiScreen {
enableClipping(bottom); enableClipping(bottom);
float yPos = height * 0.75F; float yPos = height * 0.75F;
float xPos1 = width * 0.25F; float xPos1 = width / 4;
float xPos2 = width * 0.75F; float xPos2 = width * 0.75F;
float scale = height * 0.25F; float scale = height / 4;
float lookX = mid - mouseX; float lookX = mid - mouseX;
mc.getTextureManager().bindTexture(localPlayer.getSkinTexture()); mc.getTextureManager().bindTexture(localPlayer.getLocal(Type.SKIN).getTexture());
renderPlayerModel(localPlayer, xPos1, yPos, scale, horizon - mouseY, lookX, partialTick); renderPlayerModel(localPlayer, xPos1, yPos, scale, horizon - mouseY, lookX, partialTick);
mc.getTextureManager().bindTexture(remotePlayer.getSkinTexture()); mc.getTextureManager().bindTexture(remotePlayer.getLocal(Type.SKIN).getTexture());
renderPlayerModel(remotePlayer, xPos2, yPos, scale, horizon - mouseY, lookX, partialTick); renderPlayerModel(remotePlayer, xPos2, yPos, scale, horizon - mouseY, lookX, partialTick);
disableClipping(); disableClipping();
drawCenteredString(this.fontRenderer, I18n.format("hdskins.manager"), width / 2, 10, 0xffffff); drawCenteredString(fontRenderer, I18n.format("hdskins.manager"), width / 2, 10, 0xffffff);
fontRenderer.drawStringWithShadow(I18n.format("hdskins.local"), 34, 34, 0xffffff); fontRenderer.drawStringWithShadow(I18n.format("hdskins.local"), 34, 34, 0xffffff);
fontRenderer.drawStringWithShadow(I18n.format("hdskins.server"), width / 2 + 34, 34, 0xffffff); fontRenderer.drawStringWithShadow(I18n.format("hdskins.server"), width / 2 + 34, 34, 0xffffff);
@ -424,99 +417,97 @@ public class GuiSkins extends GuiScreen {
enableBlend(); enableBlend();
depthMask(false); depthMask(false);
int labelwidth = (this.width / 2 - 80) / 2; if (!localPlayer.isUsingLocalTexture()) {
if (!this.localPlayer.isUsingLocalTexture()) { int opacity = fontRenderer.getStringWidth(skinMessage) / 2;
int opacity = this.fontRenderer.getStringWidth(this.skinMessage) / 2;
Gui.drawRect(40, this.height / 2 - 12, this.width / 2 - 40, this.height / 2 + 12, 0xB0000000); Gui.drawRect(40, height / 2 - 12, width / 2 - 40, height / 2 + 12, 0xB0000000);
this.fontRenderer.drawStringWithShadow(this.skinMessage, (int) (xPos1 - opacity), this.height / 2 - 4, 0xffffff); fontRenderer.drawStringWithShadow(skinMessage, (int) (xPos1 - opacity), height / 2 - 4, 0xffffff);
} }
if (this.btnModeSkin.isMouseOver() || this.btnModeElytra.isMouseOver() || this.btnModeSkinnySkin.isMouseOver()) { if (btnModeSkin.isMouseOver() || btnModeElytra.isMouseOver() || btnModeSkinnySkin.isMouseOver()) {
int y = Math.max(mouseY, 16); int y = Math.max(mouseY, 16);
String text; String text;
if (this.btnModeSkin.isMouseOver()) {
if (btnModeSkin.isMouseOver()) {
text = "hdskins.mode.skin"; text = "hdskins.mode.skin";
} else if (this.btnModeSkinnySkin.isMouseOver()) { } else if (btnModeSkinnySkin.isMouseOver()) {
text = "hdskins.mode.skinny"; text = "hdskins.mode.skinny";
} else { } else {
text = "hdskins.mode.elytra"; text = "hdskins.mode.elytra";
} }
this.drawHoveringText(I18n.format(text), mouseX, y);
drawHoveringText(I18n.format(text), mouseX, y);
} }
if (this.btnAbout.isMouseOver()) { if (btnAbout.isMouseOver()) {
SkinServer gateway = HDSkinManager.INSTANCE.getGatewayServer(); SkinServer gateway = HDSkinManager.INSTANCE.getGatewayServer();
this.drawHoveringText(Splitter.on("\r\n").splitToList(gateway.toString()), mouseX, mouseY); drawHoveringText(Splitter.on("\r\n").splitToList(gateway.toString()), mouseX, mouseY);
} }
if (this.fetchingSkin) { if (fetchingSkin) {
int lineHeight = throttledByMojang ? 16 : 12; int lineHeight = throttledByMojang ? 16 : 12;
Gui.drawRect((int) (xPos2 - labelwidth), this.height / 2 - lineHeight, this.width - 40, this.height / 2 + lineHeight, 0xB0000000); Gui.drawRect((int) (xPos2 - width / 4 + 40), height / 2 - lineHeight, width - 40, height / 2 + lineHeight, 0xB0000000);
if (this.throttledByMojang) { if (throttledByMojang) {
this.drawCenteredString(fontRenderer, I18n.format("hdskins.error.mojang"), (int)xPos2, height / 2 - 10, 0xffffff); drawCenteredString(fontRenderer, I18n.format("hdskins.error.mojang"), (int)xPos2, height / 2 - 10, 0xffffff);
this.drawCenteredString(fontRenderer, I18n.format("hdskins.error.mojang.wait"), (int)xPos2, height / 2 + 2, 0xffffff); drawCenteredString(fontRenderer, I18n.format("hdskins.error.mojang.wait"), (int)xPos2, height / 2 + 2, 0xffffff);
} else { } else {
this.drawCenteredString(fontRenderer, I18n.format("hdskins.fetch"), (int)xPos2, height / 2 - 4, 0xffffff); drawCenteredString(fontRenderer, I18n.format("hdskins.fetch"), (int)xPos2, height / 2 - 4, 0xffffff);
} }
} }
if (this.uploadingSkin || this.uploadOpacity > 0.0F) { if (uploadingSkin || uploadOpacity > 0) {
if (!this.uploadingSkin) { if (!uploadingSkin) {
this.uploadOpacity -= deltaTime * 0.05F; uploadOpacity -= deltaTime / 20;
} else if (this.uploadOpacity < 1.0F) { } else if (uploadOpacity < 1) {
this.uploadOpacity += deltaTime * 0.1F; uploadOpacity += deltaTime / 10;
} }
if (this.uploadOpacity > 1.0F) { if (uploadOpacity > 1) {
this.uploadOpacity = 1.0F; uploadOpacity = 1;
} }
int opacity = Math.min(180, (int) (this.uploadOpacity * 180.0F)) & 255; int opacity = Math.min(180, (int) (uploadOpacity * 180)) & 255;
if (this.uploadOpacity > 0.0F) { if (uploadOpacity > 0) {
Gui.drawRect(0, 0, this.width, this.height, opacity << 24); Gui.drawRect(0, 0, width, height, opacity << 24);
if (this.uploadingSkin) { if (uploadingSkin) {
this.drawCenteredString(this.fontRenderer, this.skinUploadMessage, this.width / 2, this.height / 2, opacity << 24 | 0xffffff); drawCenteredString(fontRenderer, skinUploadMessage, width / 2, height / 2, opacity << 24 | 0xffffff);
} }
} }
} }
if (this.uploadError != null) { if (uploadError != null) {
Gui.drawRect(0, 0, this.width, this.height, 0xB0000000); Gui.drawRect(0, 0, width, height, 0xB0000000);
this.drawCenteredString(this.fontRenderer, I18n.format("hdskins.failed"), this.width / 2, this.height / 2 - 10, 0xFFFFFF55); drawCenteredString(fontRenderer, I18n.format("hdskins.failed"), width / 2, height / 2 - 10, 0xFFFFFF55);
this.drawCenteredString(this.fontRenderer, this.uploadError, this.width / 2, this.height / 2 + 2, 0xFFFF5555); drawCenteredString(fontRenderer, uploadError, width / 2, height / 2 + 2, 0xFFFF5555);
} }
depthMask(true); depthMask(true);
enableDepth(); enableDepth();
} }
private void renderPlayerModel(EntityPlayerModel thePlayer, float xPosition, float yPosition, float scale, float mouseY, float mouseX, private void renderPlayerModel(EntityPlayerModel thePlayer, float xPosition, float yPosition, float scale, float mouseY, float mouseX, float partialTick) {
float partialTick) {
enableColorMaterial(); enableColorMaterial();
pushMatrix(); pushMatrix();
translate(xPosition, yPosition, 300.0F); translate(xPosition, yPosition, 300);
scale(-scale, scale, scale); scale(-scale, scale, scale);
rotate(180.0F, 0.0F, 0.0F, 1.0F); rotate(180, 0, 0, 1);
rotate(135.0F, 0.0F, 1.0F, 0.0F); rotate(135, 0, 1, 0);
RenderHelper.enableStandardItemLighting(); RenderHelper.enableStandardItemLighting();
rotate(-135.0F, 0.0F, 1.0F, 0.0F); rotate(-135, 0, 1, 0);
rotate(15.0F, 1.0F, 0.0F, 0.0F); rotate(15, 1, 0, 0);
rotate(((updateCounter + partialTick) * 2.5F) % 360, 0, 1, 0);
float rot = ((updateCounter + partialTick) * 2.5F) % 360; thePlayer.rotationYawHead = (float)Math.atan(mouseX / 20) * 30;
thePlayer.rotationPitch = (float)Math.atan(mouseY / 40) * -20;
rotate(rot, 0, 1, 0); translate(0, thePlayer.getYOffset(), 0);
thePlayer.rotationYawHead = ((float) Math.atan(mouseX / 20)) * 30;
thePlayer.rotationPitch = -((float) Math.atan(mouseY / 40)) * 20;
translate(0.0D, thePlayer.getYOffset(), 0.0D);
RenderManager rm = Minecraft.getMinecraft().getRenderManager(); RenderManager rm = Minecraft.getMinecraft().getRenderManager();
rm.playerViewY = 180.0F; rm.playerViewY = 180;
rm.renderEntity(thePlayer, 0, 0, 0, 0, 1, false); rm.renderEntity(thePlayer, 0, 0, 0, 0, 1, false);
popMatrix(); popMatrix();
@ -525,18 +516,18 @@ public class GuiSkins extends GuiScreen {
} }
private void enableClipping(int yBottom) { private void enableClipping(int yBottom) {
if (this.doubleBuffer == null) { if (doubleBuffer == null) {
this.doubleBuffer = BufferUtils.createByteBuffer(32).asDoubleBuffer(); doubleBuffer = BufferUtils.createByteBuffer(32).asDoubleBuffer();
} }
this.doubleBuffer.clear(); doubleBuffer.clear();
this.doubleBuffer.put(0.0D).put(1.0D).put(0.0D).put((-30)).flip(); doubleBuffer.put(0).put(1).put(0).put(-30).flip();
GL11.glClipPlane(GL11.GL_CLIP_PLANE0, this.doubleBuffer); GL11.glClipPlane(GL11.GL_CLIP_PLANE0, doubleBuffer);
this.doubleBuffer.clear(); doubleBuffer.clear();
this.doubleBuffer.put(0.0D).put(-1.0D).put(0.0D).put(yBottom).flip(); doubleBuffer.put(0).put(-1).put(0).put(yBottom).flip();
GL11.glClipPlane(GL11.GL_CLIP_PLANE1, this.doubleBuffer); GL11.glClipPlane(GL11.GL_CLIP_PLANE1, doubleBuffer);
GL11.glEnable(GL11.GL_CLIP_PLANE0); GL11.glEnable(GL11.GL_CLIP_PLANE0);
GL11.glEnable(GL11.GL_CLIP_PLANE1); GL11.glEnable(GL11.GL_CLIP_PLANE1);
} }
@ -550,42 +541,37 @@ public class GuiSkins extends GuiScreen {
return number != 0 && (number & number - 1) == 0; return number != 0 && (number & number - 1) == 0;
} }
//TODO: Garggling marbles
private void punchServer(String uploadMsg, @Nullable URI path) { private void punchServer(String uploadMsg, @Nullable URI path) {
uploadingSkin = true; uploadingSkin = true;
skinUploadMessage = I18n.format(uploadMsg); skinUploadMessage = I18n.format(uploadMsg);
HDSkinManager.INSTANCE.getGatewayServer() HDSkinManager.INSTANCE.getGatewayServer()
.uploadSkin(mc.getSession(), path, textureType, getMetadata()) .uploadSkin(mc.getSession(), path, textureType, getMetadata())
.thenAccept(this::onUploadComplete) .thenAccept(response -> {
.exceptionally(this::onFailure); LiteLoaderLogger.info("Upload completed with: %s", response);
uploadingSkin = false;
if (!response.isSuccess()) {
setUploadError(response.getMessage());
} else {
pendingRemoteSkinRefresh = true;
}
}).exceptionally(t -> {
LogManager.getLogger().warn("Upload failed", t);
setUploadError(t.toString());
uploadingSkin = false;
return null;
});
} }
private Map<String, String> getMetadata() { private Map<String, String> getMetadata() {
return ImmutableMap.of("model", this.thinArmType ? "slim" : "default"); return ImmutableMap.of("model", thinArmType ? "slim" : "default");
} }
private void setUploadError(@Nullable String error) { private void setUploadError(@Nullable String error) {
this.uploadError = error; uploadError = error;
this.btnUpload.enabled = true; btnUpload.enabled = true;
}
private Void onFailure(Throwable t) {
LogManager.getLogger().warn("Upload failed", t);
this.setUploadError(t.toString());
this.uploadingSkin = false;
return null;
}
private void onUploadComplete(SkinUploadResponse response) {
LiteLoaderLogger.info("Upload completed with: %s", response);
this.uploadingSkin = false;
if (!response.isSuccess()) {
this.setUploadError(response.getMessage());
} else {
this.pendingRemoteSkinRefresh = true;
}
} }
static { static {

41
src/hdskins/java/com/voxelmodpack/hdskins/gui/RenderPlayerModel.java
View file

@ -16,6 +16,8 @@ import net.minecraft.item.ItemStack;
import net.minecraft.util.ResourceLocation; import net.minecraft.util.ResourceLocation;
import org.lwjgl.opengl.GL11; import org.lwjgl.opengl.GL11;
import com.mojang.authlib.minecraft.MinecraftProfileTexture.Type;
import java.util.Set; import java.util.Set;
import static net.minecraft.client.renderer.GlStateManager.*; import static net.minecraft.client.renderer.GlStateManager.*;
@ -31,7 +33,7 @@ public class RenderPlayerModel<M extends EntityPlayerModel> extends RenderLiving
private static final ModelPlayer THIN = new ModelPlayer(0, true); private static final ModelPlayer THIN = new ModelPlayer(0, true);
public RenderPlayerModel(RenderManager renderer) { public RenderPlayerModel(RenderManager renderer) {
super(renderer, FAT, 0.0F); super(renderer, FAT, 0);
this.addLayer(this.getElytraLayer()); this.addLayer(this.getElytraLayer());
} }
@ -44,14 +46,14 @@ public class RenderPlayerModel<M extends EntityPlayerModel> extends RenderLiving
ItemStack itemstack = entity.getItemStackFromSlot(EntityEquipmentSlot.CHEST); ItemStack itemstack = entity.getItemStackFromSlot(EntityEquipmentSlot.CHEST);
if (itemstack.getItem() == Items.ELYTRA) { if (itemstack.getItem() == Items.ELYTRA) {
GlStateManager.color(1.0F, 1.0F, 1.0F, 1.0F); GlStateManager.color(1, 1, 1, 1);
GlStateManager.enableBlend(); GlStateManager.enableBlend();
GlStateManager.blendFunc(GlStateManager.SourceFactor.ONE, GlStateManager.DestFactor.ZERO); GlStateManager.blendFunc(GlStateManager.SourceFactor.ONE, GlStateManager.DestFactor.ZERO);
bindTexture(entity.getElytraTexture()); bindTexture(entity.getLocal(Type.ELYTRA).getTexture());
GlStateManager.pushMatrix(); GlStateManager.pushMatrix();
GlStateManager.translate(0.0F, 0.0F, 0.125F); GlStateManager.translate(0, 0, 0.125F);
modelElytra.setRotationAngles(limbSwing, limbSwingAmount, ageInTicks, netHeadYaw, headPitch, scale, entity); modelElytra.setRotationAngles(limbSwing, limbSwingAmount, ageInTicks, netHeadYaw, headPitch, scale, entity);
modelElytra.render(entity, limbSwing, limbSwingAmount, ageInTicks, netHeadYaw, headPitch, scale); modelElytra.render(entity, limbSwing, limbSwingAmount, ageInTicks, netHeadYaw, headPitch, scale);
@ -69,18 +71,18 @@ public class RenderPlayerModel<M extends EntityPlayerModel> extends RenderLiving
} }
@Override @Override
protected ResourceLocation getEntityTexture(M var1) { protected ResourceLocation getEntityTexture(M entity) {
return var1.getSkinTexture(); return entity.getLocal(Type.SKIN).getTexture();
} }
@Override @Override
protected boolean canRenderName(M targetEntity) { protected boolean canRenderName(M entity) {
return Minecraft.getMinecraft().player != null && super.canRenderName(targetEntity); return Minecraft.getMinecraft().player != null && super.canRenderName(entity);
} }
@Override @Override
protected boolean setBrightness(M entitylivingbaseIn, float partialTicks, boolean p_177092_3_) { protected boolean setBrightness(M entity, float partialTicks, boolean combineTextures) {
return Minecraft.getMinecraft().world != null && super.setBrightness(entitylivingbaseIn, partialTicks, p_177092_3_); return Minecraft.getMinecraft().world != null && super.setBrightness(entity, partialTicks, combineTextures);
} }
public ModelPlayer getEntityModel(M entity) { public ModelPlayer getEntityModel(M entity) {
@ -88,8 +90,8 @@ public class RenderPlayerModel<M extends EntityPlayerModel> extends RenderLiving
} }
@Override @Override
public void doRender(M par1Entity, double par2, double par4, double par6, float par8, float par9) { public void doRender(M entity, double x, double y, double z, float entitYaw, float partialTicks) {
ModelPlayer player = this.getEntityModel(par1Entity); ModelPlayer player = this.getEntityModel(entity);
this.mainModel = player; this.mainModel = player;
Set<EnumPlayerModelParts> parts = Minecraft.getMinecraft().gameSettings.getModelParts(); Set<EnumPlayerModelParts> parts = Minecraft.getMinecraft().gameSettings.getModelParts();
@ -104,22 +106,13 @@ public class RenderPlayerModel<M extends EntityPlayerModel> extends RenderLiving
player.rightArmPose = ArmPose.EMPTY; player.rightArmPose = ArmPose.EMPTY;
GL11.glPushAttrib(GL11.GL_ALL_ATTRIB_BITS); GL11.glPushAttrib(GL11.GL_ALL_ATTRIB_BITS);
super.doRender(par1Entity, par2, par4, par6, par8, par9); super.doRender(entity, x, y, z, entitYaw, partialTicks);
popAttrib(); popAttrib();
pushMatrix(); pushMatrix();
scale(1.0F, -1.0F, 1.0F); scale(1, -1, 1);
GL11.glPushAttrib(GL11.GL_ALL_ATTRIB_BITS); GL11.glPushAttrib(GL11.GL_ALL_ATTRIB_BITS);
super.doRender(par1Entity, par2, par4, par6, par8, par9); super.doRender(entity, x, y, z, entitYaw, partialTicks);
popAttrib(); popAttrib();
popMatrix(); popMatrix();
} }
@Override
protected void preRenderCallback(M par1EntityLiving, float par2) {
this.renderCloak(par1EntityLiving, par2);
}
protected void renderCloak(M entity, float par2) {
super.preRenderCallback(entity, par2);
}
} }

16
src/main/java/com/minelittlepony/hdskins/gui/EntityPonyModel.java
View file

@ -1,6 +1,7 @@
package com.minelittlepony.hdskins.gui; package com.minelittlepony.hdskins.gui;
import com.mojang.authlib.GameProfile; import com.mojang.authlib.GameProfile;
import com.mojang.authlib.minecraft.MinecraftProfileTexture.Type;
import com.voxelmodpack.hdskins.gui.EntityPlayerModel; import com.voxelmodpack.hdskins.gui.EntityPlayerModel;
import net.minecraft.util.ResourceLocation; import net.minecraft.util.ResourceLocation;
@ -20,19 +21,22 @@ public class EntityPonyModel extends EntityPlayerModel {
} }
@Override @Override
protected ResourceLocation getBlankSkin() { public ResourceLocation getBlankSkin(Type type) {
return wet ? NO_SKIN_SEAPONY : NO_SKIN_PONY; if (type == Type.SKIN) {
return wet ? NO_SKIN_SEAPONY : NO_SKIN_PONY;
}
return super.getBlankSkin(type);
} }
public void setWet(boolean wet) { public void setWet(boolean wet) {
this.wet = wet; this.wet = wet;
if (wet && localSkinResource == NO_SKIN_PONY) { if (wet && skin.getTexture() == NO_SKIN_PONY) {
localSkinResource = NO_SKIN_SEAPONY; skin.reset();
} }
if (!wet && localSkinResource == NO_SKIN_SEAPONY) { if (!wet && skin.getTexture() == NO_SKIN_SEAPONY) {
localSkinResource = NO_SKIN_PONY; skin.reset();
} }
} }
} }

2
src/main/java/com/minelittlepony/hdskins/gui/GuiSkinsMineLP.java
View file

@ -96,7 +96,7 @@ public class GuiSkinsMineLP extends GuiSkins {
protected void onSetLocalSkin(Type type) { protected void onSetLocalSkin(Type type) {
MineLittlePony.logger.debug("Invalidating old local skin, checking updated local skin"); MineLittlePony.logger.debug("Invalidating old local skin, checking updated local skin");
if (type == Type.SKIN) { if (type == Type.SKIN) {
ponyManager.removePony(localPlayer.getSkinTexture()); ponyManager.removePony(localPlayer.getLocal(Type.SKIN).getTexture());
} }
} }

5
src/main/java/com/minelittlepony/hdskins/gui/RenderPonyModel.java
View file

@ -8,6 +8,7 @@ import com.minelittlepony.model.player.PlayerModels;
import com.minelittlepony.pony.data.Pony; import com.minelittlepony.pony.data.Pony;
import com.minelittlepony.pony.data.PonyRace; import com.minelittlepony.pony.data.PonyRace;
import com.minelittlepony.render.layer.AbstractPonyLayer; import com.minelittlepony.render.layer.AbstractPonyLayer;
import com.mojang.authlib.minecraft.MinecraftProfileTexture.Type;
import com.voxelmodpack.hdskins.gui.RenderPlayerModel; import com.voxelmodpack.hdskins.gui.RenderPlayerModel;
import net.minecraft.client.model.ModelBase; import net.minecraft.client.model.ModelBase;
@ -52,7 +53,7 @@ public class RenderPonyModel extends RenderPlayerModel<EntityPonyModel> {
return super.getEntityModel(playermodel); return super.getEntityModel(playermodel);
} }
boolean canWet = playermodel.wet && (loc == playermodel.getBlankSkin() || race == PonyRace.SEAPONY); boolean canWet = playermodel.wet && (loc == playermodel.getBlankSkin(Type.SKIN) || race == PonyRace.SEAPONY);
ModelWrapper pm = canWet ? PlayerModels.SEAPONY.getModel(slim) : thePony.getModel(true); ModelWrapper pm = canWet ? PlayerModels.SEAPONY.getModel(slim) : thePony.getModel(true);
pm.apply(thePony.getMetadata()); pm.apply(thePony.getMetadata());
@ -75,7 +76,7 @@ public class RenderPonyModel extends RenderPlayerModel<EntityPonyModel> {
if (itemstack.getItem() == Items.ELYTRA) { if (itemstack.getItem() == Items.ELYTRA) {
GlStateManager.color(1, 1, 1, 1); GlStateManager.color(1, 1, 1, 1);
bindTexture(entity.getElytraTexture()); bindTexture(entity.getLocal(Type.ELYTRA).getTexture());
GlStateManager.pushMatrix(); GlStateManager.pushMatrix();