Merge 253b460676 into c3e02fb2d6

Minecraft.Client/ClientConnection.cpp

@@ -2805,7 +2805,7 @@ void ClientConnection::handleTextureAndGeometry(shared_ptr<TextureAndGeometryPac
 			{
 				unsigned int uiAnimOverrideBitmask= app.GetAnimOverrideBitmask(packet->dwSkinID);
 
-				send(std::make_shared<TextureAndGeometryPacket>(packet->textureName, pbData, dwBytes, app.GetAdditionalSkinBoxes(packet->dwSkinID), uiAnimOverrideBitmask));
+				send(std::make_shared<TextureAndGeometryPacket>(packet->textureName, pbData, dwBytes, app.GetAdditionalSkinBoxes(packet->dwSkinID), app.GetSkinOffsets(packet->dwSkinID), uiAnimOverrideBitmask));
 			}
 		}
 	}
@@ -2822,6 +2822,11 @@ void ClientConnection::handleTextureAndGeometry(shared_ptr<TextureAndGeometryPac
 		{
 			app.SetAdditionalSkinBoxes(packet->dwSkinID,packet->BoxDataA,packet->dwBoxC);
 		}
+		// Add the offet data
+		if(packet->dwOffsetC!=0)
+		{
+			app.SetSkinOffsets(packet->dwSkinID,packet->OffsetDataA,packet->dwOffsetC);
+		}
 		// Add the anim override
 		app.SetAnimOverrideBitmask(packet->dwSkinID,packet->uiAnimOverrideBitmask);
 

Minecraft.Client/Common/Consoles_App.cpp

@@ -201,6 +201,7 @@ CMinecraftApp::CMinecraftApp()
 	InitializeCriticalSection(&csTMSPPDownloadQueue);
 	InitializeCriticalSection(&csAdditionalModelParts);
 	InitializeCriticalSection(&csAdditionalSkinBoxes);
+	InitializeCriticalSection(&csSkinOffsets);
 	InitializeCriticalSection(&csAnimOverrideBitmask);
 	InitializeCriticalSection(&csMemFilesLock);
 	InitializeCriticalSection(&csMemTPDLock);
@@ -245,8 +246,7 @@ CMinecraftApp::CMinecraftApp()
 }
 
 
-void CMinecraftApp::GetSkinAdjustments(_SkinAdjustments* out,
-                                        unsigned int skinId)
+void CMinecraftApp::GetSkinAdjustments(_SkinAdjustments* out, unsigned int skinId)
 {
     _SkinAdjustments adj; 
 
@@ -264,8 +264,7 @@ void CMinecraftApp::GetSkinAdjustments(_SkinAdjustments* out,
     *out = adj;
 }
 
-void CMinecraftApp::SetSkinAdjustments(unsigned int skinId,
-                                        const _SkinAdjustments& adj)
+void CMinecraftApp::SetSkinAdjustments(unsigned int skinId, const _SkinAdjustments& adj)
 {
     EnterCriticalSection(&csAdditionalSkinBoxes);
 
@@ -9627,7 +9626,14 @@ void CMinecraftApp::SetAdditionalSkinBoxes(DWORD dwSkinID, SKIN_BOX *SkinBoxA, D
 {
 	EntityRenderDispatcher *dispatcher = EntityRenderDispatcher::instance;
 	EntityRenderer *renderer = dispatcher ? dispatcher->getRenderer(eTYPE_PLAYER) : nullptr;
-	Model *pModel = renderer ? renderer->getModel() : nullptr;
+	unsigned int m_uiAnimOverrideBitmask = GetAnimOverrideBitmask(dwSkinID);
+	Model *pModel;
+	if (m_uiAnimOverrideBitmask & (1 << HumanoidModel::eAnim_SlimModel))
+		pModel = renderer ? renderer->getModel(2) : nullptr;
+	else if (m_uiAnimOverrideBitmask & (1 << HumanoidModel::eAnim_WideModel))
+		pModel = renderer ? renderer->getModel(1) : nullptr;
+	else
+		pModel = renderer ? renderer->getModel(0) : nullptr;
 	vector<ModelPart *> *pvModelPart = new vector<ModelPart *>;
 	vector<SKIN_BOX *> *pvSkinBoxes = new vector<SKIN_BOX *>;
 
@@ -9660,7 +9666,14 @@ vector<ModelPart *> * CMinecraftApp::SetAdditionalSkinBoxes(DWORD dwSkinID, vect
 {
 	EntityRenderDispatcher *dispatcher = EntityRenderDispatcher::instance;
 	EntityRenderer *renderer = dispatcher ? dispatcher->getRenderer(eTYPE_PLAYER) : nullptr;
-	Model *pModel = renderer ? renderer->getModel() : nullptr;
+	unsigned int m_uiAnimOverrideBitmask = GetAnimOverrideBitmask(dwSkinID);
+	Model *pModel;
+	if (m_uiAnimOverrideBitmask & (1 << HumanoidModel::eAnim_SlimModel))
+		pModel = renderer ? renderer->getModel(2) : nullptr;
+	else if (m_uiAnimOverrideBitmask & (1 << HumanoidModel::eAnim_WideModel))
+		pModel = renderer ? renderer->getModel(1) : nullptr;
+	else
+		pModel = renderer ? renderer->getModel(0) : nullptr;
 	vector<ModelPart *> *pvModelPart = new vector<ModelPart *>;
 
 	EnterCriticalSection( &csAdditionalModelParts );
@@ -9685,6 +9698,44 @@ vector<ModelPart *> * CMinecraftApp::SetAdditionalSkinBoxes(DWORD dwSkinID, vect
 	return pvModelPart;
 }
 
+void CMinecraftApp::SetSkinOffsets(DWORD dwSkinID, SKIN_OFFSET *SkinOffsetA, DWORD dwSkinOffsetC)
+{
+	vector<SKIN_OFFSET *> *pvSkinOffset = new vector<SKIN_OFFSET *>;
+
+	EnterCriticalSection( &csSkinOffsets );
+
+	app.DebugPrintf("*** SetSkinOffsets - Adding skin offsets for skin %d from array of Skin Offsets\n",dwSkinID&0x0FFFFFFF);
+
+	for(unsigned int i=0;i<dwSkinOffsetC;i++)
+	{
+		pvSkinOffset->push_back(&SkinOffsetA[i]);
+	}
+
+
+	m_SkinOffsets.insert( std::pair<DWORD, vector<SKIN_OFFSET *> *>(dwSkinID, pvSkinOffset) );
+
+	LeaveCriticalSection( &csSkinOffsets );
+
+}
+
+vector<SKIN_OFFSET *> * CMinecraftApp::SetSkinOffsets(DWORD dwSkinID, vector<SKIN_OFFSET *> *pvSkinOffsetA)
+{
+	vector<SKIN_OFFSET *> *pvSkinOffset = new vector<SKIN_OFFSET *>;
+
+	EnterCriticalSection( &csSkinOffsets );
+	app.DebugPrintf("*** SetSkinOffsets - Inserting skin offsets for skin %d from array of Skin Offsets\n",dwSkinID&0x0FFFFFFF);
+
+	for( auto& it : *pvSkinOffsetA )
+	{
+		pvSkinOffset->push_back(it);
+	}
+
+	m_SkinOffsets.emplace(dwSkinID, pvSkinOffsetA);
+
+	LeaveCriticalSection( &csSkinOffsets );
+	return pvSkinOffset;
+}
+
 
 vector<ModelPart *> *CMinecraftApp::GetAdditionalModelParts(DWORD dwSkinID)
 {
@@ -9720,6 +9771,23 @@ vector<SKIN_BOX *> *CMinecraftApp::GetAdditionalSkinBoxes(DWORD dwSkinID)
 	return pvSkinBoxes;
 }
 
+vector<SKIN_OFFSET *> *CMinecraftApp::GetSkinOffsets(DWORD dwSkinID)
+{
+	EnterCriticalSection( &csSkinOffsets );
+	vector<SKIN_OFFSET *> *pvSkinOffsets=nullptr;
+	if(m_SkinOffsets.size()>0)
+	{
+		auto it = m_SkinOffsets.find(dwSkinID);
+		if(it!=m_SkinOffsets.end())
+		{
+			pvSkinOffsets = (*it).second;
+		}
+	}
+
+	LeaveCriticalSection( &csSkinOffsets );
+	return pvSkinOffsets;
+}
+
 unsigned int CMinecraftApp::GetAnimOverrideBitmask(DWORD dwSkinID)
 {
 	EnterCriticalSection( &csAnimOverrideBitmask );

Minecraft.Client/Common/Consoles_App.h

@@ -21,6 +21,7 @@ using namespace std;
 #include "./GameRules/ConsoleGameRulesConstants.h"
 #include "./GameRules/GameRuleManager.h"
 #include "../SkinBox.h"
+#include "../SkinOffset.h"
 #include "../ArchiveFile.h"
 #include "lce_filesystem/FolderFile.h"
 
@@ -848,6 +849,7 @@ private:
 	CRITICAL_SECTION csTMSPPDownloadQueue;
 	CRITICAL_SECTION csAdditionalModelParts;
 	CRITICAL_SECTION csAdditionalSkinBoxes;
+	CRITICAL_SECTION csSkinOffsets;
 	CRITICAL_SECTION csAnimOverrideBitmask;
 	bool m_bCorruptSaveDeleted;
 	wstring m_currentSaveFolderName; // 4J Added: for hardcore world deletion on Win64
@@ -870,6 +872,9 @@ public:
 	vector<ModelPart *> * SetAdditionalSkinBoxes(DWORD dwSkinID, vector<SKIN_BOX *> *pvSkinBoxA);
 	vector<ModelPart *> *GetAdditionalModelParts(DWORD dwSkinID);
 	vector<SKIN_BOX *> *GetAdditionalSkinBoxes(DWORD dwSkinID);
+	void SetSkinOffsets(DWORD dwSkinID, SKIN_OFFSET *SkinOffsetA, DWORD dwSkinOffsetC);
+	vector<SKIN_OFFSET *> * SetSkinOffsets(DWORD dwSkinID, vector<SKIN_OFFSET *> *pvSkinOffsetA);
+	vector<SKIN_OFFSET *> *GetSkinOffsets(DWORD dwSkinID);
 	void SetAnimOverrideBitmask(DWORD dwSkinID,unsigned int uiAnimOverrideBitmask);
 	unsigned int GetAnimOverrideBitmask(DWORD dwSkinID);
 
@@ -900,6 +905,7 @@ private:
 	// vector of additional skin model parts, indexed by the skin texture id
 	unordered_map<DWORD, vector<ModelPart *> *> m_AdditionalModelParts;
 	unordered_map<DWORD, vector<SKIN_BOX *> *> m_AdditionalSkinBoxes;
+	unordered_map<DWORD, vector<SKIN_OFFSET *> *> m_SkinOffsets;
 	unordered_map<DWORD, unsigned int> m_AnimOverrides;
 
 

Minecraft.Client/Common/DLC/DLCManager.cpp

@@ -24,6 +24,7 @@ const WCHAR *DLCManager::wchTypeNamesA[]=
 	L"ENCHANTTEXTFOCUSCOLOUR",
 	L"DATAPATH",
 	L"PACKVERSION",
+	L"OFFSET",
 };
 
 DLCManager::DLCManager()

Minecraft.Client/Common/DLC/DLCManager.h

@@ -45,6 +45,7 @@ public:
 		e_DLCParamType_EnchantmentTextFocusColour,
 		e_DLCParamType_DataPath,
 		e_DLCParamType_PackVersion,
+		e_DLCParamType_Offset,
 
 		e_DLCParamType_Max,
 

Minecraft.Client/Common/DLC/DLCSkinFile.cpp

@@ -120,9 +120,9 @@ void DLCSkinFile::addParameter(DLCManager::EDLCParameterType type, const wstring
 
 #ifdef __PS3__
 			// 4J Stu - The Xbox version used swscanf_s which isn't available in GCC.
-			swscanf(value.c_str(), L"%10ls%f%f%f%f%f%f%f%f", wchBodyPart,
+			swscanf(value.c_str(), L"%10ls%f%f%f%f%f%f%f%f%f%f%f", wchBodyPart,
 #else
-			swscanf_s(value.c_str(), L"%9ls%f%f%f%f%f%f%f%f", wchBodyPart,10,
+			swscanf_s(value.c_str(), L"%9ls%f%f%f%f%f%f%f%f%f%f%f", wchBodyPart,10,
 #endif
 				&pSkinBox->fX,
 				&pSkinBox->fY,
@@ -131,7 +131,10 @@ void DLCSkinFile::addParameter(DLCManager::EDLCParameterType type, const wstring
 				&pSkinBox->fH,
 				&pSkinBox->fD,
 				&pSkinBox->fU,
-				&pSkinBox->fV);
+				&pSkinBox->fV,
+				&pSkinBox->fA,
+				&pSkinBox->fM,
+				&pSkinBox->fS);
  
 			if(wcscmp(wchBodyPart,L"HEAD")==0)
 			{
@@ -157,11 +160,216 @@ void DLCSkinFile::addParameter(DLCManager::EDLCParameterType type, const wstring
 			{
 				pSkinBox->ePart=eBodyPart_Leg1;
 			}
+			else if(wcscmp(wchBodyPart,L"HEADWEAR")==0)
+			{
+				pSkinBox->ePart=eBodyPart_Headwear;
+			}
+			else if(wcscmp(wchBodyPart,L"JACKET")==0)
+			{
+				pSkinBox->ePart=eBodyPart_Jacket;
+			}
+			else if(wcscmp(wchBodyPart,L"SLEEVE0")==0)
+			{
+				pSkinBox->ePart=eBodyPart_Sleeve0;
+			}
+			else if(wcscmp(wchBodyPart,L"SLEEVE1")==0)
+			{
+				pSkinBox->ePart=eBodyPart_Sleeve1;
+			}
+			else if(wcscmp(wchBodyPart,L"PANTS0")==0)
+			{
+				pSkinBox->ePart=eBodyPart_Pants0;
+			}
+			else if(wcscmp(wchBodyPart,L"PANTS1")==0)
+			{
+				pSkinBox->ePart=eBodyPart_Pants1;
+			}
+			else if(wcscmp(wchBodyPart,L"WAIST")==0)
+			{
+				pSkinBox->ePart=eBodyPart_Waist;
+			}
+			else if(wcscmp(wchBodyPart,L"LEGGING0")==0)
+			{
+				pSkinBox->ePart=eBodyPart_Legging0;
+			}
+			else if(wcscmp(wchBodyPart,L"LEGGING1")==0)
+			{
+				pSkinBox->ePart=eBodyPart_Legging1;
+			}
+			else if(wcscmp(wchBodyPart,L"SOCK0")==0)
+			{
+				pSkinBox->ePart=eBodyPart_Sock0;
+			}
+			else if(wcscmp(wchBodyPart,L"SOCK1")==0)
+			{
+				pSkinBox->ePart=eBodyPart_Sock1;
+			}
+			else if(wcscmp(wchBodyPart,L"BOOT0")==0)
+			{
+				pSkinBox->ePart=eBodyPart_Boot0;
+			}
+			else if(wcscmp(wchBodyPart,L"BOOT1")==0)
+			{
+				pSkinBox->ePart=eBodyPart_Boot1;
+			}
+			else if(wcscmp(wchBodyPart,L"ARMARMOR0")==0)
+			{
+				pSkinBox->ePart=eBodyPart_ArmArmor0;
+			}
+			else if(wcscmp(wchBodyPart,L"ARMARMOR1")==0)
+			{
+				pSkinBox->ePart=eBodyPart_ArmArmor1;
+			}
+			else if(wcscmp(wchBodyPart,L"BODYARMOR")==0)
+			{
+				pSkinBox->ePart=eBodyPart_BodyArmor;
+			}
+			else if(wcscmp(wchBodyPart,L"BELT")==0)
+			{
+				pSkinBox->ePart=eBodyPart_Belt;
+			}
 
 			// add this to the skin's vector of parts
 			m_AdditionalBoxes.push_back(pSkinBox);
 		}
 		break;
+	case DLCManager::e_DLCParamType_Offset:
+		{
+			WCHAR wchBodyPart[10];
+			wchar_t wchDirection[2];
+			SKIN_OFFSET *pSkinOffset = new SKIN_OFFSET;
+			ZeroMemory(pSkinOffset,sizeof(SKIN_OFFSET));
+
+#ifdef __PS3__
+			// 4J Stu - The Xbox version used swscanf_s which isn't available in GCC.
+			swscanf(value.c_str(), L"%10ls%2ls%f", wchBodyPart,
+#else
+			swscanf_s(value.c_str(), L"%9ls%2ls%f", wchBodyPart,10, wchDirection,2,
+#endif
+				&pSkinOffset->fO);
+
+			if(wcscmp(wchDirection,L"X")==0)
+			{
+				pSkinOffset->fD=eOffsetDirection_X;
+			}
+			else if (wcscmp(wchDirection,L"Y")==0)
+			{
+				pSkinOffset->fD=eOffsetDirection_Y;
+			}
+			else if(wcscmp(wchDirection,L"Z")==0)
+			{
+				pSkinOffset->fD=eOffsetDirection_Z;
+			}
+ 
+			if(wcscmp(wchBodyPart,L"HEAD")==0)
+			{
+				pSkinOffset->ePart=eBodyOffset_Head;
+			}
+			else if(wcscmp(wchBodyPart,L"BODY")==0)
+			{
+				pSkinOffset->ePart=eBodyOffset_Body;
+			}
+			else if(wcscmp(wchBodyPart,L"ARM0")==0)
+			{
+				pSkinOffset->ePart=eBodyOffset_Arm0;
+			}
+			else if(wcscmp(wchBodyPart,L"ARM1")==0)
+			{
+				pSkinOffset->ePart=eBodyOffset_Arm1;
+			}
+			else if(wcscmp(wchBodyPart,L"LEG0")==0)
+			{
+				pSkinOffset->ePart=eBodyOffset_Leg0;
+			}
+			else if(wcscmp(wchBodyPart,L"LEG1")==0)
+			{
+				pSkinOffset->ePart=eBodyOffset_Leg1;
+			}
+			else if(wcscmp(wchBodyPart,L"HEADWEAR")==0)
+			{
+				pSkinOffset->ePart=eBodyOffset_Headwear;
+			}
+			else if(wcscmp(wchBodyPart,L"JACKET")==0)
+			{
+				pSkinOffset->ePart=eBodyOffset_Jacket;
+			}
+			else if(wcscmp(wchBodyPart,L"SLEEVE0")==0)
+			{
+				pSkinOffset->ePart=eBodyOffset_Sleeve0;
+			}
+			else if(wcscmp(wchBodyPart,L"SLEEVE1")==0)
+			{
+				pSkinOffset->ePart=eBodyOffset_Sleeve1;
+			}
+			else if(wcscmp(wchBodyPart,L"PANTS0")==0)
+			{
+				pSkinOffset->ePart=eBodyOffset_Pants0;
+			}
+			else if(wcscmp(wchBodyPart,L"PANTS1")==0)
+			{
+				pSkinOffset->ePart=eBodyOffset_Pants1;
+			}
+			else if(wcscmp(wchBodyPart,L"HELMET")==0)
+			{
+				pSkinOffset->ePart=eBodyOffset_Helmet;
+			}
+			else if(wcscmp(wchBodyPart,L"WAIST")==0)
+			{
+				pSkinOffset->ePart=eBodyOffset_Waist;
+			}
+			else if(wcscmp(wchBodyPart,L"LEGGING0")==0)
+			{
+				pSkinOffset->ePart=eBodyOffset_Legging0;
+			}
+			else if(wcscmp(wchBodyPart,L"LEGGING1")==0)
+			{
+				pSkinOffset->ePart=eBodyOffset_Legging1;
+			}
+			else if(wcscmp(wchBodyPart,L"SOCK0")==0)
+			{
+				pSkinOffset->ePart=eBodyOffset_Sock0;
+			}
+			else if(wcscmp(wchBodyPart,L"SOCK1")==0)
+			{
+				pSkinOffset->ePart=eBodyOffset_Sock1;
+			}
+			else if(wcscmp(wchBodyPart,L"BOOT0")==0)
+			{
+				pSkinOffset->ePart=eBodyOffset_Boot0;
+			}
+			else if(wcscmp(wchBodyPart,L"BOOT1")==0)
+			{
+				pSkinOffset->ePart=eBodyOffset_Boot1;
+			}
+			else if(wcscmp(wchBodyPart,L"ARMARMOR1")==0)
+			{
+				pSkinOffset->ePart=eBodyOffset_ArmArmor1;
+			}
+			else if(wcscmp(wchBodyPart,L"ARMARMOR0")==0)
+			{
+				pSkinOffset->ePart=eBodyOffset_ArmArmor0;
+			}
+			else if(wcscmp(wchBodyPart,L"BODYARMOR")==0)
+			{
+				pSkinOffset->ePart=eBodyOffset_BodyArmor;
+			}
+			else if(wcscmp(wchBodyPart,L"BELT")==0)
+			{
+				pSkinOffset->ePart=eBodyOffset_Belt;
+			}
+			else if(wcscmp(wchBodyPart,L"TOOL0")==0)
+			{
+				pSkinOffset->ePart=eBodyOffset_Tool0;
+			}
+			else if(wcscmp(wchBodyPart,L"TOOL1")==0)
+			{
+				pSkinOffset->ePart=eBodyOffset_Tool1;
+			}
+
+			// add this to the skin's vector of offsets
+			m_Offsets.push_back(pSkinOffset);
+		}
+		break;
 	case DLCManager::e_DLCParamType_Anim:
 #ifdef __PS3__
 		// 4J Stu - The Xbox version used swscanf_s which isn't available in GCC.
@@ -189,6 +397,15 @@ vector<SKIN_BOX *> *DLCSkinFile::getAdditionalBoxes()
 	return &m_AdditionalBoxes;
 }
 
+int DLCSkinFile::getOffsetsCount()
+{
+	return static_cast<int>(m_Offsets.size());
+}
+vector<SKIN_OFFSET *> *DLCSkinFile::getOffsets()
+{
+	return &m_Offsets;
+}
+
 wstring DLCSkinFile::getParameterAsString(DLCManager::EDLCParameterType type)
 {
 	switch(type)

Minecraft.Client/Common/DLC/DLCSkinFile.h

@@ -13,6 +13,7 @@ private:
 	unsigned int m_uiAnimOverrideBitmask;
 	bool m_bIsFree;
 	vector<SKIN_BOX *> m_AdditionalBoxes;
+	vector<SKIN_OFFSET *> m_Offsets;
 	_SkinAdjustments m_skinAdjustments;
 
 public:
@@ -26,6 +27,8 @@ public:
     bool getParameterAsBool(DLCManager::EDLCParameterType type) override;
 	vector<SKIN_BOX *> *getAdditionalBoxes();
 	int getAdditionalBoxesCount();
+	vector<SKIN_OFFSET *> *getOffsets();
+	int getOffsetsCount();
 	unsigned int getAnimOverrideBitmask() { return m_uiAnimOverrideBitmask;}
 	bool isFree() {return m_bIsFree;}
 };

Minecraft.Client/Common/UI/UIControl_PlayerSkinPreview.cpp

@@ -8,7 +8,6 @@
 #include "../../ModelPart.h"
 #include "../../Options.h"
 #include "../../../Minecraft.World/net.minecraft.world.entity.player.h"
-#include "Skins.h"
 #include "UIControl_PlayerSkinPreview.h"
 #include <string>
 
@@ -108,6 +107,7 @@ UIControl_PlayerSkinPreview::UIControl_PlayerSkinPreview()
 	m_framesAnimatingRotation = 0;
 	m_bAnimatingToFacing = false;
 	m_pvAdditionalModelParts=nullptr;
+	m_pvSkinOffsets=nullptr;
 	m_uiAnimOverrideBitmask=0L;
 }
 
@@ -184,6 +184,7 @@ void UIControl_PlayerSkinPreview::SetTexture(const wstring &url, TEXTURE_NAME ba
 	}
 
 	m_pvAdditionalModelParts=app.GetAdditionalModelParts(app.getSkinIdFromPath(m_customTextureUrl));
+	m_pvSkinOffsets=app.GetSkinOffsets(app.getSkinIdFromPath(m_customTextureUrl));
 }
 
 void UIControl_PlayerSkinPreview::SetFacing(ESkinPreviewFacing facing, bool bAnimate /*= false*/)
@@ -309,24 +310,8 @@ void UIControl_PlayerSkinPreview::render(EntityRenderer *renderer, double x, dou
 	glPushMatrix();
 	glDisable(GL_CULL_FACE);
 
-	HumanoidModel *model = static_cast<HumanoidModel *>(renderer->getModel());
-	Textures *textures = Minecraft::GetInstance()->textures;
-	int skinId = textures->loadMemTexture(m_customTextureUrl, m_backupTexture) - 37;
-
-	if (slim[skinId] == true)
-	{
-		if (textures->getHeight(m_customTextureUrl, m_backupTexture) == 64)
-			model = static_cast<HumanoidModel *>(renderer->getNewModelSlim());
-		else
-			model = static_cast<HumanoidModel *>(renderer->getModelSlim());
-	}
-	else
-	{
-		if (textures->getHeight(m_customTextureUrl, m_backupTexture) == 64)
-			model = static_cast<HumanoidModel *>(renderer->getNewModel());
-		else
-			model = static_cast<HumanoidModel *>(renderer->getModel());
-	}
+	Textures *t = Minecraft::GetInstance()->textures;
+	HumanoidModel *model = static_cast<HumanoidModel *>(renderer->getModel(Player::GetModelTypeFromTextureId(t->loadMemTexture(m_customTextureUrl, m_backupTexture)-36)+Player::GetModelTypeFromAnimBitmask(m_uiAnimOverrideBitmask)));
 
 	//getAttackAnim(mob, a);
 	//if (armor != nullptr) armor->attackTime = model->attackTime;
@@ -438,7 +423,7 @@ void UIControl_PlayerSkinPreview::render(EntityRenderer *renderer, double x, dou
 	glEnable(GL_ALPHA_TEST);
 
 	//model->prepareMobModel(mob, wp, ws, a);
-	model->render(nullptr, wp, ws, bob, headRot - bodyRot, headRotx, _scale, true);
+	model->renderUI(wp, ws, bob, headRot - bodyRot, headRotx, _scale, true, m_pvSkinOffsets);
 	/*for (int i = 0; i < MAX_ARMOR_LAYERS; i++)
 	{
 	if (prepareArmor(mob, i, a))

Minecraft.Client/Common/UI/UIControl_PlayerSkinPreview.h

@@ -53,6 +53,7 @@ private:
 	ESkinPreviewAnimations m_currentAnimation;
 	//vector<Model::SKIN_BOX *> *m_pvAdditionalBoxes;
 	vector<ModelPart *> *m_pvAdditionalModelParts;
+	vector<SKIN_OFFSET *> *m_pvSkinOffsets;
 public:
 	enum ESkinPreviewFacing
 	{

Minecraft.Client/Common/UI/UIScene_SkinSelectMenu.cpp

@@ -24,16 +24,16 @@ const WCHAR *UIScene_SkinSelectMenu::wchDefaultNamesA[]=
 	L"Prisoner Steve",
 	L"Cyclist Steve",
 	L"Boxer Steve",
-	L"Developer Steve",
 	L"Alex",
-	L"Tuxedo Alex",
-	L"Boxer Alex",
-	L"Prisoner Alex",
 	L"Tennis Alex",
-	L"Cyclist Alex",
+	L"Tuxedo Alex",
 	L"Athlete Alex",
 	L"Swedish Alex",
+	L"Prisoner Alex",
+	L"Cyclist Alex",
+	L"Boxer Alex",
 	L"Developer Alex",
+	L"Developer Steve",
 };
 
 UIScene_SkinSelectMenu::UIScene_SkinSelectMenu(int iPad, void *initData, UILayer *parentLayer) : UIScene(iPad, parentLayer)
@@ -59,6 +59,7 @@ UIScene_SkinSelectMenu::UIScene_SkinSelectMenu(int iPad, void *initData, UILayer
 	m_selectedSkinPath = L"";
 	m_selectedCapePath = L"";
 	m_vAdditionalSkinBoxes = nullptr;
+	m_vSkinOffsets = nullptr;
 
 	m_bSlidingSkins = false;
 	m_bAnimatingMove = false;
@@ -662,6 +663,7 @@ void UIScene_SkinSelectMenu::handleSkinIndexChanged()
 		m_selectedSkinPath = skinFile->getPath();
 		m_selectedCapePath = skinFile->getParameterAsString(DLCManager::e_DLCParamType_Cape);
 		m_vAdditionalSkinBoxes = skinFile->getAdditionalBoxes();
+		m_vSkinOffsets = skinFile->getOffsets();
 
 		skinName = skinFile->getParameterAsString( DLCManager::e_DLCParamType_DisplayName );
 		skinOrigin = skinFile->getParameterAsString( DLCManager::e_DLCParamType_ThemeName );
@@ -684,6 +686,7 @@ void UIScene_SkinSelectMenu::handleSkinIndexChanged()
 		m_selectedSkinPath = L"";
 		m_selectedCapePath = L"";
 		m_vAdditionalSkinBoxes = nullptr;
+		m_vSkinOffsets = nullptr;
 
 		switch(m_packIndex)
 		{
@@ -726,6 +729,7 @@ void UIScene_SkinSelectMenu::handleSkinIndexChanged()
 					m_selectedSkinPath = skinFile->getPath();
 					m_selectedCapePath = skinFile->getParameterAsString(DLCManager::e_DLCParamType_Cape);
 					m_vAdditionalSkinBoxes = skinFile->getAdditionalBoxes();
+					m_vSkinOffsets = skinFile->getOffsets();
 
 					skinName = skinFile->getParameterAsString( DLCManager::e_DLCParamType_DisplayName );
 					skinOrigin = skinFile->getParameterAsString( DLCManager::e_DLCParamType_ThemeName );
@@ -773,6 +777,17 @@ void UIScene_SkinSelectMenu::handleSkinIndexChanged()
 			pAdditionalModelParts = app.SetAdditionalSkinBoxes(skinFile->getSkinID(),m_vAdditionalSkinBoxes);
 		}
 	}
+	
+	if(m_vSkinOffsets && m_vSkinOffsets->size()!=0)
+	{
+		// add the skin Offsets to the humanoid model, but only if we've not done this already
+
+		vector<SKIN_OFFSET *> *pSkinOffsets = app.GetSkinOffsets(skinFile->getSkinID());
+		if(pSkinOffsets==nullptr)
+		{
+			pSkinOffsets = app.SetSkinOffsets(skinFile->getSkinID(),m_vSkinOffsets);
+		}
+	}
 
 	if(skinFile!=nullptr)
 	{
@@ -790,6 +805,7 @@ void UIScene_SkinSelectMenu::handleSkinIndexChanged()
 	wstring otherSkinPath = L"";
 	wstring otherCapePath = L"";
 	vector<SKIN_BOX *> *othervAdditionalSkinBoxes=nullptr;
+	vector<SKIN_OFFSET *> *othervSkinOffsets=nullptr;
 	wchar_t chars[256];
 
 	// turn off all displays
@@ -844,6 +860,7 @@ void UIScene_SkinSelectMenu::handleSkinIndexChanged()
 				otherSkinPath = skinFile->getPath();
 				otherCapePath = skinFile->getParameterAsString(DLCManager::e_DLCParamType_Cape);
 				othervAdditionalSkinBoxes = skinFile->getAdditionalBoxes();
+				othervSkinOffsets = skinFile->getOffsets();
 				backupTexture = TN_MOB_CHAR;
 			}
 			else
@@ -851,6 +868,7 @@ void UIScene_SkinSelectMenu::handleSkinIndexChanged()
 				otherSkinPath = L"";
 				otherCapePath = L"";
 				othervAdditionalSkinBoxes=nullptr;
+				othervSkinOffsets=nullptr;
 				switch(m_packIndex)
 				{
 				case SKIN_SELECT_PACK_DEFAULT:
@@ -870,6 +888,7 @@ void UIScene_SkinSelectMenu::handleSkinIndexChanged()
 							otherSkinPath = skinFile->getPath();
 							otherCapePath = skinFile->getParameterAsString(DLCManager::e_DLCParamType_Cape);
 							othervAdditionalSkinBoxes = skinFile->getAdditionalBoxes();
+							othervSkinOffsets = skinFile->getOffsets();
 							backupTexture = TN_MOB_CHAR;
 						}
 					}
@@ -887,6 +906,14 @@ void UIScene_SkinSelectMenu::handleSkinIndexChanged()
 					pAdditionalModelParts = app.SetAdditionalSkinBoxes(skinFile->getSkinID(),othervAdditionalSkinBoxes);
 				}
 			}
+			if(othervSkinOffsets && othervSkinOffsets->size()!=0)
+			{
+				vector<SKIN_OFFSET *> *pSkinOffsets = app.GetSkinOffsets(skinFile->getSkinID());
+				if(pSkinOffsets==nullptr)
+				{
+					pSkinOffsets = app.SetSkinOffsets(skinFile->getSkinID(),othervSkinOffsets);
+				}
+			}
 			// 4J-PB - anim override needs set before SetTexture
 			if(skinFile!=nullptr)
 			{
@@ -915,6 +942,7 @@ void UIScene_SkinSelectMenu::handleSkinIndexChanged()
 				otherSkinPath = skinFile->getPath();
 				otherCapePath = skinFile->getParameterAsString(DLCManager::e_DLCParamType_Cape);
 				othervAdditionalSkinBoxes = skinFile->getAdditionalBoxes();
+				othervSkinOffsets = skinFile->getOffsets();
 				backupTexture = TN_MOB_CHAR;
 			}
 			else
@@ -922,6 +950,7 @@ void UIScene_SkinSelectMenu::handleSkinIndexChanged()
 				otherSkinPath = L"";
 				otherCapePath = L"";
 				othervAdditionalSkinBoxes=nullptr;
+				othervSkinOffsets=nullptr;
 				switch(m_packIndex)
 				{
 				case SKIN_SELECT_PACK_DEFAULT:
@@ -941,6 +970,7 @@ void UIScene_SkinSelectMenu::handleSkinIndexChanged()
 							otherSkinPath = skinFile->getPath();
 							otherCapePath = skinFile->getParameterAsString(DLCManager::e_DLCParamType_Cape);
 							othervAdditionalSkinBoxes = skinFile->getAdditionalBoxes();
+							othervSkinOffsets = skinFile->getOffsets();
 							backupTexture = TN_MOB_CHAR;
 						}
 					}
@@ -958,6 +988,14 @@ void UIScene_SkinSelectMenu::handleSkinIndexChanged()
 					pAdditionalModelParts = app.SetAdditionalSkinBoxes(skinFile->getSkinID(),othervAdditionalSkinBoxes);
 				}
 			}
+			if(othervSkinOffsets && othervSkinOffsets->size()!=0)
+			{
+				vector<SKIN_OFFSET *> *pSkinOffsets = app.GetSkinOffsets(skinFile->getSkinID());
+				if(pSkinOffsets==nullptr)
+				{
+					pSkinOffsets = app.SetSkinOffsets(skinFile->getSkinID(),othervSkinOffsets);
+				}
+			}
 			// 4J-PB - anim override needs set before SetTexture
 			if(skinFile)
 			{
@@ -1004,34 +1042,34 @@ TEXTURE_NAME UIScene_SkinSelectMenu::getTextureId(int skinIndex)
 		texture = TN_MOB_CHAR7;
 		break;
 	case eDefaultSkins_Skin8:
-		texture = TN_MOB_CHAR8;
+		texture = TN_MOB_ALEX;
 		break;
 	case eDefaultSkins_Skin9:
-		texture = TN_MOB_CHAR9;
+		texture = TN_MOB_ALEX1;
 		break;
 	case eDefaultSkins_Skin10:
-		texture = TN_MOB_CHAR10;
+		texture = TN_MOB_ALEX2;
 		break;
 	case eDefaultSkins_Skin11:
-		texture = TN_MOB_CHAR11;
+		texture = TN_MOB_ALEX3;
 		break;
 	case eDefaultSkins_Skin12:
-		texture = TN_MOB_CHAR12;
+		texture = TN_MOB_ALEX4;
 		break;
 	case eDefaultSkins_Skin13:
-		texture = TN_MOB_CHAR13;
+		texture = TN_MOB_ALEX5;
 		break;
 	case eDefaultSkins_Skin14:
-		texture = TN_MOB_CHAR14;
+		texture = TN_MOB_ALEX6;
 		break;
 	case eDefaultSkins_Skin15:
-		texture = TN_MOB_CHAR15;
+		texture = TN_MOB_ALEX7;
 		break;
 	case eDefaultSkins_Skin16:
-		texture = TN_MOB_CHAR16;
+		texture = TN_MOB_DEVALEX;
 		break;
 	case eDefaultSkins_Skin17:
-		texture = TN_MOB_CHAR17;
+		texture = TN_MOB_DEVSTEVE;
 		break;
 	};
 

Minecraft.Client/Common/UI/UIScene_SkinSelectMenu.h

@@ -104,6 +104,7 @@ private:
 	DWORD m_originalSkinId;
 	wstring m_currentSkinPath, m_selectedSkinPath, m_selectedCapePath;
 	vector<SKIN_BOX *> *m_vAdditionalSkinBoxes;
+	vector<SKIN_OFFSET *> *m_vSkinOffsets;
 
 	bool m_bSlidingSkins, m_bAnimatingMove;
 	ESkinSelectNavigation m_currentNavigation;

Minecraft.Client/EntityRenderer.cpp

@@ -19,9 +19,8 @@ ResourceLocation EntityRenderer::SHADOW_LOCATION = ResourceLocation(TN__CLAMP__M
 EntityRenderer::EntityRenderer()
 {
 	model = nullptr;
+	modelWide = nullptr;
 	modelSlim = nullptr;
-	newModel = nullptr;
-	newModelSlim = nullptr;
 	tileRenderer = new TileRenderer();
 	shadowRadius = 0;
 	shadowStrength = 1.0f;
@@ -407,6 +406,13 @@ void EntityRenderer::registerTerrainTextures(IconRegister *iconRegister)
 {
 }
 
+Model *EntityRenderer::getModel(int modelType)
+{
+	if (modelType == 2) return modelSlim;
+	else if (modelType == 1) return modelWide;
+	else return model;
+}
+
 
 ResourceLocation *EntityRenderer::getTextureLocation(shared_ptr<Entity> mob)
 {

Minecraft.Client/EntityRenderer.h

@@ -31,9 +31,8 @@ private:
 
 protected:
 	Model *model;			// TODO 4J: Check why exactly this is here, it seems to get shadowed by classes inheriting from this by their own
+	Model *modelWide;
 	Model *modelSlim;
-	Model *newModel;
-	Model *newModelSlim;
 
 protected:
     TileRenderer *tileRenderer;	// 4J - changed to protected so derived classes can use instead of shadowing their own
@@ -71,10 +70,7 @@ public:
 
 public:
 	// 4J Added
-	virtual Model *getModel() { return model; }
-	virtual Model *getModelSlim() { return modelSlim; }
-	virtual Model *getNewModel() { return newModel; }
-	virtual Model *getNewModelSlim() { return newModelSlim; }
+	virtual Model *getModel(int modelType = 0);
 	virtual void SetItemFrame(bool bSet) {}
 	virtual bool shouldRender(shared_ptr<Entity> entity, float camX, float camY, float camZ) { return true; }
 

Minecraft.Client/HumanoidModel.h

@@ -1,9 +1,11 @@
 #pragma once
 #include "Model.h"
+#include "SkinOffset.h"
 class HumanoidModel : public Model
 {
 public:
     ModelPart* head, * hair, * body, * jacket, * arm0, * sleeve0, * arm1, * sleeve1, * leg0, * pants0, * leg1, * pants1, * ear, * cloak;
+	ModelPart* waist, * belt, * bodyArmor, * armArmor0, * armArmor1, * legging0, * legging1, * sock0, * sock1, * boot0, * boot1;
     ModelPart* elytraLeft, * elytraRight;
     int holdingLeftHand;
     int holdingRightHand;
@@ -15,6 +17,8 @@ public:
     float eating_swing;	
     bool elytraFlying;    
     bool elytraCrouching; 
+    bool m_isArmor;
+	bool m_is64x64;
     unsigned int m_uiAnimOverrideBitmask; 
     float m_fYOffset;
     enum animbits
@@ -37,11 +41,20 @@ public:
         eAnim_DisableRenderLeg1,
         eAnim_DisableRenderHair,
         eAnim_SmallModel,
-        eAnim_DisableRenderJacket,
-        eAnim_DisableRenderSleeve0,
-        eAnim_DisableRenderSleeve1,
-        eAnim_DisableRenderPants0,
-        eAnim_DisableRenderPants1
+		eAnim_WideModel,
+		eAnim_SlimModel,
+		eAnim_DisableRenderSleeve1,
+		eAnim_DisableRenderSleeve0,
+		eAnim_DisableRenderPants1,
+		eAnim_DisableRenderPants0,
+		eAnim_DisableRenderJacket,
+		eAnim_RenderArmorHead,
+		eAnim_RenderArmorArm0,
+		eAnim_RenderArmorArm1,
+		eAnim_RenderArmorTorso,
+		eAnim_RenderArmorLeg0,
+		eAnim_RenderArmorLeg1,
+		eAnim_Dinnerbone
     };
 
 
@@ -59,22 +72,17 @@ public:
         (1 << HumanoidModel::eAnim_DisableRenderPants0) |
         (1 << HumanoidModel::eAnim_DisableRenderPants1);
 
-    void _init(float g, float yOffset, int texWidth, int texHeight,
-               bool slimHands, bool mirror, bool force32);
+    void _init(float g, float yOffset, int texWidth, int texHeight, bool slim, bool isArmor);
 
     HumanoidModel();
     HumanoidModel(float g);
+    HumanoidModel(float g, bool isArmor);
     HumanoidModel(float g, float yOffset, int texWidth, int texHeight);
-    HumanoidModel(float g, float yOffset, int texWidth, int texHeight, bool slimHands);
-    HumanoidModel(float g, float yOffset, int texWidth, int texHeight, bool slimHands, bool mirror);
-    HumanoidModel(float g, float yOffset, int texWidth, int texHeight, bool slimHands, bool mirror, bool force32);
-
-    virtual void render(shared_ptr<Entity> entity, float time, float r, float bob,
-                        float yRot, float xRot, float scale, bool usecompiled);
-    virtual void setupAnim(float time, float r, float bob, float yRot, float xRot,
-                           float scale, shared_ptr<Entity> entity,
-                           unsigned int uiBitmaskOverrideAnim = 0);
+    HumanoidModel(float g, float yOffset, int texWidth, int texHeight, bool slim);
 
+    virtual void render(shared_ptr<Entity> entity, float time, float r, float bob, float yRot, float xRot, float scale, bool usecompiled);
+	virtual void renderUI(float time, float r, float bob, float yRot, float xRot, float scale, bool usecompiled, vector<SKIN_OFFSET *> *skinOffsets);
+    virtual void setupAnim(float time, float r, float bob, float yRot, float xRot, float scale, shared_ptr<Entity> entity, unsigned int uiBitmaskOverrideAnim = 0);
     void renderHair(float scale, bool usecompiled);
     void renderEars(float scale, bool usecompiled);
     void renderCloak(float scale, bool usecompiled);

Minecraft.Client/ItemInHandRenderer.cpp

@@ -399,8 +399,8 @@ void ItemInHandRenderer::renderItem3D(Tesselator *t, float u0, float v0, float u
 
 void ItemInHandRenderer::render(float a)
 {
-    float h = oHeight + (height - oHeight) * a;
-    shared_ptr<Player> player = minecraft->player;
+	float h = oHeight + (height - oHeight) * a;
+	shared_ptr<Player> player = minecraft->player;
 
 	if (player == nullptr)
 	{
@@ -900,8 +900,8 @@ void ItemInHandRenderer::renderFire(float a)
 	unsigned int col = Minecraft::GetInstance()->getColourTable()->getColor( eMinecraftColour_Fire_Overlay );
 	float aCol = ( (col>>24)&0xFF )/255.0f;
 	float rCol = ( (col>>16)&0xFF )/255.0f;
-	float gCol = ( (col>>8)&0xFF )/255.0;
-	float bCol = ( col&0xFF )/255.0;
+	float gCol = ( (col>>8)&0xFF )/255.0f;
+	float bCol = ( col&0xFF )/255.0f;
 
     glColor4f(rCol, gCol, bCol, aCol);
     glEnable(GL_BLEND);

Minecraft.Client/LivingEntityRenderer.cpp

@@ -8,29 +8,23 @@
 #include "../Minecraft.World/Arrow.h"
 #include "../Minecraft.World/Mth.h"
 #include "../Minecraft.World/Player.h"
-#include "Skins.h"
-
 
 ResourceLocation LivingEntityRenderer::ENCHANT_GLINT_LOCATION = ResourceLocation(TN__BLUR__MISC_GLINT);
 int LivingEntityRenderer::MAX_ARMOR_LAYERS = 4;
 
-LivingEntityRenderer::LivingEntityRenderer(Model *model, float shadow, bool slimHands, bool createNewVar)
+LivingEntityRenderer::LivingEntityRenderer(Model *model, float shadow, bool isPlayer)
 {
 	this->model = model;
 
-	if (slimHands == true)
-		this->modelSlim = new HumanoidModel(0, 0, 64, 32, true);
-
-	if (createNewVar)
+	if (isPlayer)
 	{
-		this->newModel = new HumanoidModel(0, 0, 64, 64, false, false);
-
-		if (slimHands == true)
-			this->newModelSlim = new HumanoidModel(0, 0, 64, 64, true, false);
+		this->modelWide = new HumanoidModel(0, 0, 64, 64);
+		this->modelSlim = new HumanoidModel(0, 0, 64, 64, true);
 	}
 
 	shadowRadius = shadow;
 	armor = nullptr;
+	resModel = model;
 }
 
 void LivingEntityRenderer::setArmor(Model *armor)
@@ -38,6 +32,11 @@ void LivingEntityRenderer::setArmor(Model *armor)
 	this->armor = armor;
 }
 
+void LivingEntityRenderer::setPlayerModelType(Model *humanoidModel)
+{
+	resModel = humanoidModel;
+}
+
 float LivingEntityRenderer::rotlerp(float from, float to, float a)
 {
 	float diff = to - from;
@@ -56,8 +55,6 @@ void LivingEntityRenderer::render(shared_ptr<Entity> _mob, double x, double y, d
 	}
 
 	shared_ptr<LivingEntity> mob = dynamic_pointer_cast<LivingEntity>(_mob);
-	shared_ptr<Player> player = dynamic_pointer_cast<Player>(_mob);
-	Model *resModel = static_cast<HumanoidModel *>(model);
 
 	if (mob == nullptr)
 	{
@@ -67,30 +64,6 @@ void LivingEntityRenderer::render(shared_ptr<Entity> _mob, double x, double y, d
 	glPushMatrix();
 	glDisable(GL_CULL_FACE);
 
-	if (player != nullptr)
-	{
-		Textures *textures = Minecraft::GetInstance()->textures;
-		int skinId = player->getPlayerDefaultSkin() - 1;
-		int defaultSkin = player->getPlayerDefaultSkin() + 35;
-
-		if (slim[skinId] == true)
-		{
-			if (textures->getHeight(player->customTextureUrl, defaultSkin) == 64)
-				resModel = static_cast<HumanoidModel *>(newModelSlim);
-			else
-				resModel = static_cast<HumanoidModel *>(modelSlim);
-		}
-		else
-		{
-			if (textures->getHeight(player->customTextureUrl, defaultSkin) == 64)
-				resModel = static_cast<HumanoidModel *>(newModel);
-			else
-				resModel = static_cast<HumanoidModel *>(model);
-		}
-	}
-	else
-		resModel = static_cast<HumanoidModel *>(model);
-
 	resModel->attackTime = getAttackAnim(mob, a);
 	if (armor != nullptr) armor->attackTime = resModel->attackTime;
 	resModel->riding = mob->isRiding();
@@ -281,33 +254,6 @@ void LivingEntityRenderer::render(shared_ptr<Entity> _mob, double x, double y, d
 
 void LivingEntityRenderer::renderModel(shared_ptr<LivingEntity> mob, float wp, float ws, float bob, float headRotMinusBodyRot, float headRotx, float scale)
 {
-	shared_ptr<Player> player = dynamic_pointer_cast<Player>(mob);
-	Model *resModel = static_cast<HumanoidModel *>(model);
-
-	if (player != nullptr)
-	{
-		Textures *textures = Minecraft::GetInstance()->textures;
-		int skinId = player->getPlayerDefaultSkin() - 1;
-		int defaultSkin = player->getPlayerDefaultSkin() + 35;
-
-		if (slim[skinId] == true)
-		{
-			if (textures->getHeight(player->customTextureUrl, defaultSkin) == 64)
-				resModel = static_cast<HumanoidModel *>(newModelSlim);
-			else
-				resModel = static_cast<HumanoidModel *>(modelSlim);
-		}
-		else
-		{
-			if (textures->getHeight(player->customTextureUrl, defaultSkin) == 64)
-				resModel = static_cast<HumanoidModel *>(newModel);
-			else
-				resModel = static_cast<HumanoidModel *>(model);
-		}
-	}
-	else
-		resModel = static_cast<HumanoidModel *>(model);
-
 	bindTexture(mob);
 	if (!mob->isInvisible())
 	{
@@ -351,7 +297,7 @@ void LivingEntityRenderer::setupRotations(shared_ptr<LivingEntity> mob, float bo
 	else
 	{
 		wstring name = mob->getAName();
-		if (name == L"Dinnerbone" || name == L"Grumm")
+		if (name == L"Dinnerbone" || name == L"Grumm" || mob->getAnimOverrideBitmask() & (1 << HumanoidModel::eAnim_Dinnerbone))
 		{
 			if ( !mob->instanceof(eTYPE_PLAYER) || !dynamic_pointer_cast<Player>(mob)->isCapeHidden() )
 			{
@@ -379,33 +325,6 @@ void LivingEntityRenderer::additionalRendering(shared_ptr<LivingEntity> mob, flo
 
 void LivingEntityRenderer::renderArrows(shared_ptr<LivingEntity> mob, float a)
 {
-	shared_ptr<Player> player = dynamic_pointer_cast<Player>(mob);
-	Model *resModel = static_cast<HumanoidModel *>(model);
-
-	if (player != nullptr)
-	{
-		Textures *textures = Minecraft::GetInstance()->textures;
-		int skinId = player->getPlayerDefaultSkin() - 1;
-		int defaultSkin = player->getPlayerDefaultSkin() + 35;
-
-		if (slim[skinId] == true)
-		{
-			if (textures->getHeight(player->customTextureUrl, defaultSkin) == 64)
-				resModel = static_cast<HumanoidModel *>(newModelSlim);
-			else
-				resModel = static_cast<HumanoidModel *>(modelSlim);
-		}
-		else
-		{
-			if (textures->getHeight(player->customTextureUrl, defaultSkin) == 64)
-				resModel = static_cast<HumanoidModel *>(newModel);
-			else
-				resModel = static_cast<HumanoidModel *>(model);
-		}
-	}
-	else
-		resModel = static_cast<HumanoidModel *>(model);
-
 	int arrowCount = mob->getArrowCount();
 
 	if (arrowCount > 0)

Minecraft.Client/LivingEntityRenderer.h

@@ -17,11 +17,13 @@ class LivingEntityRenderer : public EntityRenderer
 protected:
 	//Model *model; // 4J Stu - This shadows the one in EntityRenderer
 	Model *armor;
+	Model *resModel;
 
 public:
-	LivingEntityRenderer(Model *model, float shadow, bool slimHands = 0, bool createNewVar = 0);
+	LivingEntityRenderer(Model *model, float shadow, bool isPlayer = false);
 	virtual void render(shared_ptr<Entity> mob, double x, double y, double z, float rot, float a);
 	virtual void setArmor(Model *armor);
+	virtual void setPlayerModelType(Model *humanoidModel);
 
 private:
 	float rotlerp(float from, float to, float a);

Minecraft.Client/ModelPart.cpp

@@ -14,6 +14,8 @@ void ModelPart::_init()
 	bMirror = false;
 	visible = true;
 	neverRender = false;
+	hideWithArmor = 0L;
+	isArmorPart2 = false;
 	x=y=z = 0.0f;
 	xRot=yRot=zRot = 0.0f;
 	translateX = translateY = translateZ = 0.0f;

Minecraft.Client/ModelPart.h

@@ -17,6 +17,8 @@ public:
 	bool bMirror;
 	bool visible;
 	bool neverRender;
+	unsigned int hideWithArmor;
+	bool isArmorPart2;
     vector <Cube *> cubes;
     vector <ModelPart *> children;
     static const float RAD;

Minecraft.Client/PlayerConnection.cpp

@@ -1651,9 +1651,10 @@ void PlayerConnection::handleTextureAndGeometry(shared_ptr<TextureAndGeometryPac
 			{
 				// we don't have the dlc skin, so retrieve the data from the app store
 				vector<SKIN_BOX *> *pvSkinBoxes = app.GetAdditionalSkinBoxes(packet->dwSkinID);
+				vector<SKIN_OFFSET *> *pvSkinOffsets = app.GetSkinOffsets(packet->dwSkinID);
 				unsigned int uiAnimOverrideBitmask= app.GetAnimOverrideBitmask(packet->dwSkinID);
 
-				send(std::make_shared<TextureAndGeometryPacket>(packet->textureName, pbData, dwTextureBytes, pvSkinBoxes, uiAnimOverrideBitmask));
+				send(std::make_shared<TextureAndGeometryPacket>(packet->textureName, pbData, dwTextureBytes, pvSkinBoxes, pvSkinOffsets, uiAnimOverrideBitmask));
 			}
 		}
 		else
@@ -1676,6 +1677,13 @@ void PlayerConnection::handleTextureAndGeometry(shared_ptr<TextureAndGeometryPac
 			wprintf(L"Adding skin boxes for skin id %X, box count %d\n",packet->dwSkinID,packet->dwBoxC);
 #endif
 			app.SetAdditionalSkinBoxes(packet->dwSkinID,packet->BoxDataA,packet->dwBoxC);
+		}// add the offsets to the app list
+		if(packet->dwOffsetC!=0)
+		{
+#ifndef _CONTENT_PACKAGE
+			wprintf(L"Adding skin offsets for skin id %X, offset count %d\n",packet->dwSkinID,packet->dwOffsetC);
+#endif
+			app.SetSkinOffsets(packet->dwSkinID,packet->OffsetDataA,packet->dwOffsetC);
 		}
 		// Add the anim override
 		app.SetAnimOverrideBitmask(packet->dwSkinID,packet->uiAnimOverrideBitmask);
@@ -1726,9 +1734,10 @@ void PlayerConnection::handleTextureAndGeometryReceived(const wstring &textureNa
 				// get the data from the app
 				DWORD dwSkinID = app.getSkinIdFromPath(textureName);
 				vector<SKIN_BOX *> *pvSkinBoxes = app.GetAdditionalSkinBoxes(dwSkinID);
+				vector<SKIN_OFFSET *> *pvSkinOffsets = app.GetSkinOffsets(dwSkinID);
 				unsigned int uiAnimOverrideBitmask= app.GetAnimOverrideBitmask(dwSkinID);
 
-				send(std::make_shared<TextureAndGeometryPacket>(textureName, pbData, dwTextureBytes, pvSkinBoxes, uiAnimOverrideBitmask));
+				send(std::make_shared<TextureAndGeometryPacket>(textureName, pbData, dwTextureBytes, pvSkinBoxes, pvSkinOffsets, uiAnimOverrideBitmask));
 			}
 			m_texturesRequested.erase(it);
 		}

Minecraft.Client/PlayerRenderer.cpp

@@ -16,7 +16,6 @@
 #include "../Minecraft.World/StringHelpers.h"
 #include "SkeletonHeadModel.h"
 #include "Textures.h"
-#include "Skins.h"
 
 ResourceLocation PlayerRenderer::SKELETON_LOCATION = ResourceLocation(TN_MOB_SKELETON);
 ResourceLocation PlayerRenderer::WITHER_SKELETON_LOCATION = ResourceLocation(TN_MOB_WITHER_SKELETON);
@@ -64,16 +63,26 @@ static unsigned int nametagColorForIndex(int index)
 
 ResourceLocation PlayerRenderer::DEFAULT_LOCATION = ResourceLocation(TN_MOB_CHAR);
 
-PlayerRenderer::PlayerRenderer() : LivingEntityRenderer(new HumanoidModel(0), 0.5f, true, true)
+PlayerRenderer::PlayerRenderer() : LivingEntityRenderer(new HumanoidModel(0), 0.5f, true)
 {
 	humanoidModel = static_cast<HumanoidModel*>(model);
+	humanoidModelWide = static_cast<HumanoidModel*>(modelWide);
 	humanoidModelSlim = static_cast<HumanoidModel*>(modelSlim);
-	newHumanoidModel = static_cast<HumanoidModel*>(newModel);
-	newHumanoidModelSlim = static_cast<HumanoidModel*>(newModelSlim);
+	resModel = humanoidModel;
 
-	armorParts1 = new HumanoidModel(1.0f);
-	armorParts2 = new HumanoidModel(0.5f);
-	armorParts3 = new HumanoidModel(0.5f);
+	armorParts1 = new HumanoidModel(1.0f, true);
+	armorParts2 = new HumanoidModel(0.5f, true);
+	armorParts3 = new HumanoidModel(0.5f, true);
+}
+
+void PlayerRenderer::setModelType(shared_ptr<Player> player)
+{
+	if (Player::GetModelTypeFromTextureId(player->getCustomSkin()) == 2 || Player::GetModelTypeFromAnimBitmask(player->getAnimOverrideBitmask()) == 2)
+		resModel = humanoidModelSlim;
+	else if (Player::GetModelTypeFromTextureId(player->getCustomSkin()) == 1 || Player::GetModelTypeFromAnimBitmask(player->getAnimOverrideBitmask()) == 1)
+		resModel = humanoidModelWide;
+	else
+		resModel = humanoidModel;
 }
 
 unsigned int PlayerRenderer::getNametagColour(int index)
@@ -115,10 +124,14 @@ int PlayerRenderer::prepareArmor(shared_ptr<LivingEntity> _player, int layer, fl
 			armor->leg0->visible = layer == 2 || layer == 3;
 			armor->leg1->visible = layer == 2 || layer == 3;
 
+			armor->body->isArmorPart2 = layer == 2;
+			armor->leg0->isArmorPart2 = layer == 2;
+			armor->leg1->isArmorPart2 = layer == 2;
+
 			setArmor(armor);
-			if (armor != nullptr) armor->attackTime = model->attackTime;
-			if (armor != nullptr) armor->riding = model->riding;
-			if (armor != nullptr) armor->young = model->young;
+			if (armor != nullptr) armor->attackTime = resModel->attackTime;
+			if (armor != nullptr) armor->riding = resModel->riding;
+			if (armor != nullptr) armor->young = resModel->young;
 
 			float brightness = SharedConstants::TEXTURE_LIGHTING ? 1 : player->getBrightness(a);
 			if (armorItem->getMaterial() == ArmorItem::ArmorMaterial::CLOTH)
@@ -221,38 +234,12 @@ void PlayerRenderer::render(shared_ptr<Entity> _mob, double x, double y, double
 
 	// 4J - dynamic cast required because we aren't using templates/generics in our version
 	shared_ptr<Player> mob = dynamic_pointer_cast<Player>(_mob);
-	HumanoidModel* resModel = static_cast<HumanoidModel*>(model);
 
 	if (mob == nullptr) return;
 	if (mob->hasInvisiblePrivilege()) return;
 
-	if (mob != nullptr)
-	{
-		Textures* textures = Minecraft::GetInstance()->textures;
-		int skinId = mob->getPlayerDefaultSkin() - 1;
-		int defaultSkin = mob->getPlayerDefaultSkin() + 35;
-
-		if (slim[skinId] == true)
-		{
-			if (textures->getHeight(mob->customTextureUrl, defaultSkin) == 64)
-				resModel = static_cast<HumanoidModel*>(newHumanoidModelSlim);
-			else
-				resModel = static_cast<HumanoidModel*>(humanoidModelSlim);
-		}
-		else
-		{
-			if (textures->getHeight(mob->customTextureUrl, defaultSkin) == 64)
-				resModel = static_cast<HumanoidModel*>(newHumanoidModel);
-			else
-				resModel = static_cast<HumanoidModel*>(humanoidModel);
-		}
-	}
-	else
-		resModel = static_cast<HumanoidModel*>(model);
-
-	/*if (mob != nullptr && newHumanoidModelSlim != nullptr && (mob->getCustomSkin() >= 10 && mob->getCustomSkin() <= 18)) resModel = newHumanoidModelSlim;
-	else if (mob != nullptr && newHumanoidModel != nullptr && (mob->getCustomSkin() >= 2 && mob->getCustomSkin() <= 9)) resModel = newHumanoidModel;
-	else resModel = humanoidModel;*/
+	setModelType(mob);
+	setPlayerModelType(resModel);
 
 	shared_ptr<ItemInstance> item = mob->inventory->getSelected();
 
@@ -341,6 +328,12 @@ void PlayerRenderer::render(shared_ptr<Entity> _mob, double x, double y, double
 		armorParts2->idle = false;
 	}
 
+	// Get armor in armor slot so we can hide the armor layer of the skin - Langtanium
+	shared_ptr<ItemInstance> itemHelmet = mob->inventory->getArmor(3);
+	shared_ptr<ItemInstance> itemChestplate = mob->inventory->getArmor(2);
+	shared_ptr<ItemInstance> itemLeggings = mob->inventory->getArmor(1);
+	shared_ptr<ItemInstance> itemBoots = mob->inventory->getArmor(0);
+
 	// 4J-PB - any additional parts to turn on for this player (skin dependent)
 	vector<ModelPart*>* pAdditionalModelParts = mob->GetAdditionalModelParts();
 	//turn them on
@@ -348,7 +341,16 @@ void PlayerRenderer::render(shared_ptr<Entity> _mob, double x, double y, double
 	{
 		for (ModelPart* pModelPart : *pAdditionalModelParts)
 		{
-			pModelPart->visible = true;
+			if (itemHelmet != nullptr && pModelPart->hideWithArmor & (1 << 0)) // Hide the skin boxes that have the "hide when helmet is worn" bit flag - Langtanium
+				pModelPart->visible = false;
+			else if (itemChestplate != nullptr && pModelPart->hideWithArmor & (1 << 1)) // Hide the skin boxes that have the "hide when chestplate is worn" bit flag - Langtanium
+				pModelPart->visible = false;
+			else if (itemLeggings != nullptr && pModelPart->hideWithArmor & (1 << 2)) // Hide the skin boxes that have the "hide when leggings are worn" bit flag - Langtanium
+				pModelPart->visible = false;
+			else if (itemBoots != nullptr && pModelPart->hideWithArmor & (1 << 3)) // Hide the skin boxes that have the "hide when boots are worn" bit flag - Langtanium
+				pModelPart->visible = false;
+			else
+				pModelPart->visible = true;
 		}
 	}
 
@@ -379,35 +381,6 @@ void PlayerRenderer::additionalRendering(shared_ptr<LivingEntity> _mob, float a)
 
 	// 4J - dynamic cast required because we aren't using templates/generics in our version
 	shared_ptr<Player> mob = dynamic_pointer_cast<Player>(_mob);
-	HumanoidModel* resModel = static_cast<HumanoidModel*>(model);
-
-	if (mob != nullptr)
-	{
-		Textures* textures = Minecraft::GetInstance()->textures;
-		int skinId = mob->getPlayerDefaultSkin() - 1;
-		int defaultSkin = mob->getPlayerDefaultSkin() + 35;
-
-		if (slim[skinId] == true)
-		{
-			if (textures->getHeight(mob->customTextureUrl, defaultSkin) == 64)
-				resModel = static_cast<HumanoidModel*>(newHumanoidModelSlim);
-			else
-				resModel = static_cast<HumanoidModel*>(humanoidModelSlim);
-		}
-		else
-		{
-			if (textures->getHeight(mob->customTextureUrl, defaultSkin) == 64)
-				resModel = static_cast<HumanoidModel*>(newHumanoidModel);
-			else
-				resModel = static_cast<HumanoidModel*>(humanoidModel);
-		}
-	}
-	else
-		resModel = static_cast<HumanoidModel*>(model);
-
-	/*if (mob != nullptr && newHumanoidModelSlim != nullptr && (mob->getCustomSkin() >= 10 && mob->getCustomSkin() <= 18)) resModel = newHumanoidModelSlim;
-	else if (mob != nullptr && newHumanoidModel != nullptr && (mob->getCustomSkin() >= 2 && mob->getCustomSkin() <= 9)) resModel = newHumanoidModel;
-	else resModel = humanoidModel;*/
 
 	shared_ptr<ItemInstance> headGear = mob->inventory->getArmor(3);
 	if (headGear != nullptr)
@@ -510,7 +483,7 @@ void PlayerRenderer::additionalRendering(shared_ptr<LivingEntity> _mob, float a)
 		glRotatef(lean2 / 2, 0, 0, 1);
 		glRotatef(-lean2 / 2, 0, 1, 0);
 		glRotatef(180, 0, 1, 0);
-		resModel->renderCloak(1 / 16.0f, true);
+		humanoidModel->renderCloak(1 / 16.0f, true);
 		glPopMatrix();
 	}
 
@@ -741,35 +714,7 @@ void PlayerRenderer::scale(shared_ptr<LivingEntity> player, float a)
 void PlayerRenderer::renderHand()
 {
 	shared_ptr<Player> player = dynamic_pointer_cast<Player>(Minecraft::GetInstance()->player);
-	HumanoidModel* resModel = static_cast<HumanoidModel*>(model);
-
-	if (player != nullptr)
-	{
-		Textures* textures = Minecraft::GetInstance()->textures;
-		int skinId = player->getPlayerDefaultSkin() - 1;
-		int defaultSkin = player->getPlayerDefaultSkin() + 35;
-
-		if (slim[skinId] == true)
-		{
-			if (textures->getHeight(player->customTextureUrl, defaultSkin) == 64)
-				resModel = static_cast<HumanoidModel*>(newHumanoidModelSlim);
-			else
-				resModel = static_cast<HumanoidModel*>(humanoidModelSlim);
-		}
-		else
-		{
-			if (textures->getHeight(player->customTextureUrl, defaultSkin) == 64)
-				resModel = static_cast<HumanoidModel*>(newHumanoidModel);
-			else
-				resModel = static_cast<HumanoidModel*>(humanoidModel);
-		}
-	}
-	else
-		resModel = static_cast<HumanoidModel*>(model);
-
-	/*if (player != nullptr && newHumanoidModelSlim != nullptr && (player->getCustomSkin() >= 10 && player->getCustomSkin() <= 18)) resModel = newHumanoidModelSlim;
-	else if (player != nullptr && newHumanoidModel != nullptr && (player->getCustomSkin() >= 2 && player->getCustomSkin() <= 9)) resModel = newHumanoidModel;
-	else resModel = humanoidModel;*/
+	setModelType(player);
 
 	float brightness = 1;
 	glColor3f(brightness, brightness, brightness);
@@ -781,9 +726,12 @@ void PlayerRenderer::renderHand()
 	// 4J-PB - does this skin have its arm0 disabled? (Dalek, etc)
 	if ((resModel->m_uiAnimOverrideBitmask & (1 << HumanoidModel::eAnim_DisableRenderArm0)) == 0)
 		resModel->arm0->render(1 / 16.0f, true);
+	// Does this skin have its sleeve0 disabled?
+	if ((resModel->m_uiAnimOverrideBitmask & (1 << HumanoidModel::eAnim_DisableRenderSleeve0)) == 0 && resModel->sleeve0 != nullptr)
+		resModel->sleeve0->render(1 / 16.0f, true);
 
 	//Render custom skin boxes on viewmodel - Botch
-	vector<ModelPart*>* additionalModelParts = Minecraft::GetInstance()->player->GetAdditionalModelParts();
+	vector<ModelPart*>* additionalModelParts = player->GetAdditionalModelParts();
 	if (!additionalModelParts) return; //If there are no custom boxes, return. This fixes bug where the game will crash if you select a skin with no additional boxes.
 	vector<ModelPart*> armchildren = resModel->arm0->children;
 	std::unordered_set<ModelPart*> additionalModelPartSet(additionalModelParts->begin(), additionalModelParts->end());
@@ -801,6 +749,25 @@ void PlayerRenderer::renderHand()
 			}
 		}
 	}
+	//Render custom skin boxes on viewmodel for sleeve0
+	if (resModel->sleeve0!=nullptr)
+	{
+		vector<ModelPart*> sleevechildren = resModel->sleeve0->children;
+		for (const auto& x : sleevechildren) {
+			if (x) {
+				if (additionalModelPartSet.find(x) != additionalModelPartSet.end()) { //This is to verify box is still actually on current skin
+					glPushMatrix();
+					//We need to transform to match offset of arm/sleeve
+					glTranslatef(-5 * 0.0625f, 2 * 0.0625f, 0);
+					glRotatef(0.1 * (180.0f / PI), 0, 0, 1);
+					x->visible = true;
+					x->render(1.0f / 16.0f, true);
+					x->visible = false;
+					glPopMatrix();
+				}
+			}
+		}
+	}
 }
 
 void PlayerRenderer::setupPosition(shared_ptr<LivingEntity> _mob, double x, double y, double z)
@@ -857,7 +824,7 @@ void PlayerRenderer::setupRotations(shared_ptr<LivingEntity> _mob, float bob, fl
 		}
 
 	}
-		else
+	else
 	{
         LivingEntityRenderer::setupRotations(mob, bob, bodyRot, a);
     }

Minecraft.Client/PlayerRenderer.h

@@ -14,9 +14,9 @@ public:
 
 private:
 	HumanoidModel *humanoidModel;
+	HumanoidModel *humanoidModelWide;
 	HumanoidModel *humanoidModelSlim;
-	HumanoidModel *newHumanoidModel;
-	HumanoidModel *newHumanoidModelSlim;
+	HumanoidModel *resModel;
 
     HumanoidModel *armorParts1;
     HumanoidModel *armorParts2;
@@ -38,6 +38,7 @@ private:
 	static const wstring MATERIAL_NAMES[5];
 
 protected:
+	virtual void setModelType(shared_ptr<Player> player);
 	virtual int prepareArmor(shared_ptr<LivingEntity> _player, int layer, float a);
 	virtual void prepareSecondPassArmor(shared_ptr<LivingEntity> mob, int layer, float a);
 

Minecraft.Client/SkinBox.h

@@ -9,16 +9,28 @@ enum eBodyPart
 	eBodyPart_Arm1,
 	eBodyPart_Leg0,
 	eBodyPart_Leg1,
+	eBodyPart_Headwear,
 	eBodyPart_Jacket,
 	eBodyPart_Sleeve0,
 	eBodyPart_Sleeve1,
 	eBodyPart_Pants0,
 	eBodyPart_Pants1,
+	eBodyPart_Waist,
+	eBodyPart_Legging0,
+	eBodyPart_Legging1,
+	eBodyPart_Sock0,
+	eBodyPart_Sock1,
+	eBodyPart_Boot0,
+	eBodyPart_Boot1,
+	eBodyPart_ArmArmor0,
+	eBodyPart_ArmArmor1,
+	eBodyPart_BodyArmor,
+	eBodyPart_Belt
 };
 
 typedef struct 
 {
 	eBodyPart ePart;
-	float fX,fY,fZ,fW,fH,fD,fU,fV;
+	float fX,fY,fZ,fW,fH,fD,fU,fV,fA,fM,fS;
 }
 SKIN_BOX;

Minecraft.Client/SkinOffset.h

@@ -0,0 +1,48 @@
+#pragma once
+
+enum eBodyOffset
+{
+	eBodyOffset_Unknown=0,
+	eBodyOffset_Head,
+	eBodyOffset_Body,
+	eBodyOffset_Arm0,
+	eBodyOffset_Arm1,
+	eBodyOffset_Leg0,
+	eBodyOffset_Leg1,
+	eBodyOffset_Headwear,
+	eBodyOffset_Jacket,
+	eBodyOffset_Sleeve0,
+	eBodyOffset_Sleeve1,
+	eBodyOffset_Pants0,
+	eBodyOffset_Pants1,
+	eBodyOffset_Helmet,
+	eBodyOffset_Waist,
+	eBodyOffset_Legging0,
+	eBodyOffset_Legging1,
+	eBodyOffset_Sock0,
+	eBodyOffset_Sock1,
+	eBodyOffset_Boot0,
+	eBodyOffset_Boot1,
+	eBodyOffset_ArmArmor1,
+	eBodyOffset_ArmArmor0,
+	eBodyOffset_BodyArmor,
+	eBodyOffset_Belt,
+	eBodyOffset_Tool0,
+	eBodyOffset_Tool1
+	
+};
+
+enum eOffsetDirection
+{
+	eOffsetDirection_Unknown=0,
+	eOffsetDirection_X,
+	eOffsetDirection_Y,
+	eOffsetDirection_Z
+};
+
+typedef struct 
+{
+	eBodyOffset ePart;
+	float fD, fO;
+}
+SKIN_OFFSET;

Minecraft.Client/Skins.h

@@ -1,29 +0,0 @@
-#pragma once
-#include <map>
-using namespace std;
-
-class AABB;
-class Recipy;
-class Object;
-
-static std::map<int, bool> slim = {
-    { 0, false },
-	{ 1, false },
-	{ 2, false },
-	{ 3, false },
-	{ 4, false },
-	{ 5, false },
-	{ 6, false },
-	{ 7, false },
-	{ 8, false },
-	{ 9, true },
-	{ 10, true },
-	{ 11, true },
-	{ 12, true },
-	{ 13, true },
-	{ 14, true },
-	{ 15, true },
-	{ 16, true },
-	{ 17, true },
-	{ 18, true },
-};

Minecraft.Client/Textures.cpp

@@ -72,16 +72,16 @@ const wchar_t *Textures::preLoaded[TN_COUNT] =
 	L"mob/char5",
 	L"mob/char6",
 	L"mob/char7",
-	L"mob/char8",
-	L"mob/char9",
-	L"mob/char10",
-	L"mob/char11",
-	L"mob/char12",
-	L"mob/char13",
-	L"mob/char14",
-	L"mob/char15",
-	L"mob/char16",
-	L"mob/char17",
+	L"mob/alex",
+	L"mob/alex1",
+	L"mob/alex2",
+	L"mob/alex3",
+	L"mob/alex4",
+	L"mob/alex5",
+	L"mob/alex6",
+	L"mob/alex7",
+	L"mob/DevAlex",
+	L"mob/DevSteve",
 	L"terrain/moon",
 	L"terrain/sun",
 	L"armor/power",
@@ -1703,16 +1703,16 @@ TEXTURE_NAME OriginalImages[] =
 	TN_MOB_CHAR5,
 	TN_MOB_CHAR6,
 	TN_MOB_CHAR7,
-	TN_MOB_CHAR8,
-	TN_MOB_CHAR9,
-	TN_MOB_CHAR10,
-	TN_MOB_CHAR11,
-	TN_MOB_CHAR12,
-	TN_MOB_CHAR13,
-	TN_MOB_CHAR14,
-	TN_MOB_CHAR15,
-	TN_MOB_CHAR16,
-	TN_MOB_CHAR17,
+	TN_MOB_ALEX,
+	TN_MOB_ALEX1,
+	TN_MOB_ALEX2,
+	TN_MOB_ALEX3,
+	TN_MOB_ALEX4,
+	TN_MOB_ALEX5,
+	TN_MOB_ALEX6,
+	TN_MOB_ALEX7,
+	TN_MOB_DEVALEX,
+	TN_MOB_DEVSTEVE,
 
 	TN_MISC_MAPBG,
 

Minecraft.Client/Textures.h

@@ -63,16 +63,16 @@ typedef enum _TEXTURE_NAME
 	TN_MOB_CHAR5,
 	TN_MOB_CHAR6,
 	TN_MOB_CHAR7,
-	TN_MOB_CHAR8,
-	TN_MOB_CHAR9,
-	TN_MOB_CHAR10,
-	TN_MOB_CHAR11,
-	TN_MOB_CHAR12,
-	TN_MOB_CHAR13,
-	TN_MOB_CHAR14,
-	TN_MOB_CHAR15,
-	TN_MOB_CHAR16,
-	TN_MOB_CHAR17,
+	TN_MOB_ALEX,
+	TN_MOB_ALEX1,
+	TN_MOB_ALEX2,
+	TN_MOB_ALEX3,
+	TN_MOB_ALEX4,
+	TN_MOB_ALEX5,
+	TN_MOB_ALEX6,
+	TN_MOB_ALEX7,
+	TN_MOB_DEVALEX,
+	TN_MOB_DEVSTEVE,
 	TN_TERRAIN_MOON,
 	TN_TERRAIN_SUN,
 	TN_POWERED_CREEPER,

Minecraft.Client/VillagerZombieModel.cpp

@@ -25,12 +25,12 @@ void VillagerZombieModel::_init(float g, float yOffset, bool isArmor)
 	head->compile(1.0f/16.0f);
 }
 
-VillagerZombieModel::VillagerZombieModel() : HumanoidModel(0, 0, 64, 64, false, true, true)
+VillagerZombieModel::VillagerZombieModel() : HumanoidModel(0, 0, 64, 64)
 {
 	_init(0, 0, false);
 }
 
-VillagerZombieModel::VillagerZombieModel(float g, float yOffset, bool isArmor) : HumanoidModel(g, 0, 64, isArmor ? 32 : 64 , false, true, isArmor ? true : false)
+VillagerZombieModel::VillagerZombieModel(float g, float yOffset, bool isArmor) : HumanoidModel(g, 0, 64, isArmor ? 32 : 64)
 {
 	_init(g, yOffset, isArmor);
 }

Minecraft.World/Player.cpp

@@ -110,6 +110,10 @@ void Player::_init()
 	m_bCheckedForModelParts=false;
 	m_bCheckedDLCForModelParts=false;
 
+	m_ppSkinOffsets=nullptr;
+	m_bCheckedForSkinOffsets=false;
+	m_bCheckedDLCForSkinOffsets=false;
+
 #if defined(__PS3__) || defined(__ORBIS__)
 	m_ePlayerNameValidState=ePlayerNameValid_NotSet;
 #endif
@@ -724,7 +728,9 @@ void Player::setCustomSkin(DWORD skinId)
 	m_bCheckedDLCForModelParts=false;
 	this->SetAdditionalModelParts(nullptr);
 
-
+	m_bCheckedForSkinOffsets=false;
+	m_bCheckedDLCForSkinOffsets=false;
+	this->SetSkinOffsets(nullptr);
 }
 
 unsigned int Player::getSkinAnimOverrideBitmask(DWORD skinId)
@@ -2903,25 +2909,25 @@ int Player::getTexture()
 	case eDefaultSkins_Skin7:
 		return TN_MOB_CHAR7; // 4J - was L"/mob/char7.png";
 	case eDefaultSkins_Skin8:
-		return TN_MOB_CHAR8; // 4J - was L"/mob/char8.png";
+		return TN_MOB_ALEX; // 4J - was L"/mob/alex.png";
 	case eDefaultSkins_Skin9:
-		return TN_MOB_CHAR9; // 4J - was L"/mob/char9.png";
+		return TN_MOB_ALEX1; // 4J - was L"/mob/alex1.png";
 	case eDefaultSkins_Skin10:
-		return TN_MOB_CHAR10; // 4J - was L"/mob/char10.png";
+		return TN_MOB_ALEX2; // 4J - was L"/mob/alex2.png";
 	case eDefaultSkins_Skin11:
-		return TN_MOB_CHAR11; // 4J - was L"/mob/char11.png";
+		return TN_MOB_ALEX3; // 4J - was L"/mob/alex3.png";
 	case eDefaultSkins_Skin12:
-		return TN_MOB_CHAR12; // 4J - was L"/mob/char12.png";
+		return TN_MOB_ALEX4; // 4J - was L"/mob/alex4.png";
 	case eDefaultSkins_Skin13:
-		return TN_MOB_CHAR13; // 4J - was L"/mob/char13.png";
+		return TN_MOB_ALEX5; // 4J - was L"/mob/alex5.png";
 	case eDefaultSkins_Skin14:
-		return TN_MOB_CHAR14; // 4J - was L"/mob/char14.png";
+		return TN_MOB_ALEX6; // 4J - was L"/mob/alex6.png";
 	case eDefaultSkins_Skin15:
-		return TN_MOB_CHAR15; // 4J - was L"/mob/char15.png";
+		return TN_MOB_ALEX7; // 4J - was L"/mob/alex7.png";
 	case eDefaultSkins_Skin16:
-		return TN_MOB_CHAR16; // 4J - was L"/mob/char16.png";
+		return TN_MOB_DEVALEX; // 4J - was L"/mob/DevAlex.png";
 	case eDefaultSkins_Skin17:
-		return TN_MOB_CHAR17; // 4J - was L"/mob/char17.png";
+		return TN_MOB_DEVSTEVE; // 4J - was L"/mob/DevSteve.png";
 
 	default:
 		return TN_MOB_CHAR; // 4J - was L"/mob/char.png";
@@ -3389,11 +3395,71 @@ vector<ModelPart *> *Player::GetAdditionalModelParts()
 	return m_ppAdditionalModelParts;
 }
 
+vector<SKIN_OFFSET *> *Player::GetSkinOffsets()
+{
+	if(m_ppSkinOffsets==nullptr && !m_bCheckedForSkinOffsets)
+	{
+		bool hasCustomTexture = !customTextureUrl.empty();
+		bool customTextureIsDefaultSkin = customTextureUrl.substr(0,3).compare(L"def") == 0;
+
+		// see if we can find the parts
+		m_ppSkinOffsets=app.GetSkinOffsets(m_dwSkinId);
+
+		// If it's a default texture (which has no parts), we have the parts, or we already have the texture (in which case we should have parts if there are any) then we are done
+		if(!hasCustomTexture || customTextureIsDefaultSkin || m_ppSkinOffsets != nullptr || app.IsFileInMemoryTextures(customTextureUrl))
+		{
+			m_bCheckedForSkinOffsets=true;
+		}
+		if(m_ppSkinOffsets == nullptr && !m_bCheckedDLCForSkinOffsets)
+		{
+			m_bCheckedDLCForSkinOffsets = true;
+
+			// we don't have the data from the dlc skin yet
+			app.DebugPrintf("m_bCheckedForModelOffsets Couldn't get skin offsets for skin %X\n",m_dwSkinId);
+
+			// do we have it from the DLC pack?
+			DLCSkinFile *pDLCSkinFile = app.m_dlcManager.getSkinFile(this->customTextureUrl);
+
+			if(pDLCSkinFile!=nullptr)
+			{
+				DWORD dwOffsetC=pDLCSkinFile->getOffsetsCount();
+				if(dwOffsetC!=0)
+				{
+					app.DebugPrintf("m_bCheckedForSkinOffsets Got skin offsets from DLCskin for skin %X\n",m_dwSkinId);
+					m_ppSkinOffsets=app.SetSkinOffsets(m_dwSkinId,pDLCSkinFile->getOffsets());
+				}
+
+				m_bCheckedForSkinOffsets=true;
+			}
+		}
+	}
+	return m_ppSkinOffsets;
+}
+
+int Player::GetModelTypeFromAnimBitmask(unsigned int animBitmask)
+{
+	if (animBitmask&(1<<HumanoidModel::eAnim_SlimModel)) return 2;
+	else if (animBitmask&(1<<HumanoidModel::eAnim_WideModel)) return 1;
+	else return 0;
+}
+
+int Player::GetModelTypeFromTextureId(int textureId)
+{
+	if (textureId > 8 && textureId < 18) return 2;
+	else if (textureId == 18) return 1;
+	else return 0;
+}
+
 void Player::SetAdditionalModelParts(vector<ModelPart *> *ppAdditionalModelParts)
 {
 	m_ppAdditionalModelParts=ppAdditionalModelParts;
 }
 
+void Player::SetSkinOffsets(vector<SKIN_OFFSET *> *ppSkinOffsets)
+{
+	m_ppSkinOffsets=ppSkinOffsets;
+}
+
 #if defined(__PS3__) || defined(__ORBIS__)
 
 Player::ePlayerNameValidState Player::GetPlayerNameValidState(void)

Minecraft.World/Player.h

@@ -442,6 +442,8 @@ public:
 	static DWORD getCapeIdFromPath(const wstring &cape);
 	static wstring getCapePathFromId(DWORD capeId);
 	static unsigned int getSkinAnimOverrideBitmask(DWORD skinId);
+	static int GetModelTypeFromAnimBitmask(unsigned int uiAnimOverrideBitmask);
+	static int GetModelTypeFromTextureId(int textureId);
 
 	// 4J Added
 	void setXuid(PlayerUID xuid);
@@ -553,6 +555,8 @@ public:
 
 	vector<ModelPart *> *GetAdditionalModelParts();
 	void SetAdditionalModelParts(vector<ModelPart *> *ppAdditionalModelParts);
+	vector<SKIN_OFFSET *> *GetSkinOffsets();
+	void SetSkinOffsets(vector<SKIN_OFFSET *> *ppSkinOffsets);
 
 #if defined(__PS3__) || defined(__ORBIS__)
 	enum ePlayerNameValidState
@@ -569,6 +573,9 @@ private:
 	vector<ModelPart *> *m_ppAdditionalModelParts;
 	bool m_bCheckedForModelParts;
 	bool m_bCheckedDLCForModelParts;
+	vector<SKIN_OFFSET *> *m_ppSkinOffsets;
+	bool m_bCheckedForSkinOffsets;
+	bool m_bCheckedDLCForSkinOffsets;
 
 #if defined(__PS3__) || defined(__ORBIS__)
 	ePlayerNameValidState m_ePlayerNameValidState; // 4J-PB - to ensure we have the characters for this name in our font, or display a player number instead

Minecraft.World/TextureAndGeometryPacket.cpp

@@ -12,7 +12,9 @@ TextureAndGeometryPacket::TextureAndGeometryPacket()
 	this->dwTextureBytes = 0;
 	this->pbData = nullptr;
 	this->dwBoxC = 0;
+	this->dwOffsetC = 0;
 	this->BoxDataA = nullptr;
+	this->OffsetDataA = nullptr;
 	uiAnimOverrideBitmask=0;
 }
 
@@ -43,7 +45,9 @@ TextureAndGeometryPacket::TextureAndGeometryPacket(const wstring &textureName, P
 	this->pbData = pbData;
 	this->dwTextureBytes = dwBytes;
 	this->dwBoxC = 0;
+	this->dwOffsetC = 0;
 	this->BoxDataA=nullptr;
+	this->OffsetDataA=nullptr;
 	this->uiAnimOverrideBitmask=0;
 }
 
@@ -62,6 +66,7 @@ TextureAndGeometryPacket::TextureAndGeometryPacket(const wstring &textureName, P
 	this->dwTextureBytes = dwBytes;
 	this->uiAnimOverrideBitmask = pDLCSkinFile->getAnimOverrideBitmask();
 	this->dwBoxC = pDLCSkinFile->getAdditionalBoxesCount();
+	this->dwOffsetC = pDLCSkinFile->getOffsetsCount();
 	if(this->dwBoxC!=0)
 	{
 		this->BoxDataA= new SKIN_BOX [this->dwBoxC];
@@ -77,9 +82,24 @@ TextureAndGeometryPacket::TextureAndGeometryPacket(const wstring &textureName, P
 	{
 		this->BoxDataA=nullptr;
 	}
+	if(this->dwOffsetC!=0)
+	{
+		this->OffsetDataA= new SKIN_OFFSET [this->dwOffsetC];
+		vector<SKIN_OFFSET *> *pSkinOffsets=pDLCSkinFile->getOffsets();
+		int iCount=0;
+
+		for(auto& pSkinOffset : *pSkinOffsets)
+		{
+			this->OffsetDataA[iCount++]=*pSkinOffset;
+		}
+	}
+	else
+	{
+		this->OffsetDataA=nullptr;
+	}
 }
 
-TextureAndGeometryPacket::TextureAndGeometryPacket(const wstring &textureName, PBYTE pbData, DWORD dwBytes,vector<SKIN_BOX *> *pvSkinBoxes, unsigned int uiAnimOverrideBitmask)
+TextureAndGeometryPacket::TextureAndGeometryPacket(const wstring &textureName, PBYTE pbData, DWORD dwBytes, vector<SKIN_BOX *> *pvSkinBoxes, vector<SKIN_OFFSET *> *pvSkinOffsets, unsigned int uiAnimOverrideBitmask)
 {
 	this->textureName = textureName;
 
@@ -109,6 +129,22 @@ TextureAndGeometryPacket::TextureAndGeometryPacket(const wstring &textureName, P
 			this->BoxDataA[iCount++]=*pSkinBox;
 		}
 	}
+	if(pvSkinOffsets==nullptr)
+	{
+		this->dwOffsetC=0;
+		this->OffsetDataA=nullptr;
+	}
+	else
+	{
+		this->dwOffsetC = static_cast<DWORD>(pvSkinOffsets->size());
+		this->OffsetDataA= new SKIN_OFFSET [this->dwOffsetC];
+		int iCount=0;
+
+		for(auto& pSkinOffset : *pvSkinOffsets)
+		{
+			this->OffsetDataA[iCount++]=*pSkinOffset;
+		}
+	}
 
 }
 
@@ -148,6 +184,7 @@ void TextureAndGeometryPacket::read(DataInputStream *dis) //throws IOException
 	uiAnimOverrideBitmask = dis->readInt();
 
 	short rawBoxC = dis->readShort();
+	short rawOffsetC = dis->readShort();
     if (rawBoxC <= 0)
     {
         dwBoxC = 0;
@@ -160,11 +197,27 @@ void TextureAndGeometryPacket::read(DataInputStream *dis) //throws IOException
             dwBoxC = 0; // sane limit for skin boxes
         }
     }
+	if (rawOffsetC <= 0)
+    {
+        dwOffsetC = 0;
+    }
+    else
+    {
+        dwOffsetC = (DWORD)(unsigned short)rawOffsetC;
+        if (dwOffsetC > 256)
+        {
+            dwOffsetC = 0; // sane limit for skin offsets
+        }
+    }
 
 	if(dwBoxC>0)
 	{
 		this->BoxDataA= new SKIN_BOX [dwBoxC];
 	}
+	if(dwOffsetC>0)
+	{
+		this->OffsetDataA= new SKIN_OFFSET [dwOffsetC];
+	}
 
 	for(DWORD i=0;i<dwBoxC;i++)
 	{
@@ -177,10 +230,19 @@ void TextureAndGeometryPacket::read(DataInputStream *dis) //throws IOException
 		this->BoxDataA[i].fD = dis->readFloat();
 		this->BoxDataA[i].fU = dis->readFloat();
 		this->BoxDataA[i].fV = dis->readFloat();
+		this->BoxDataA[i].fA = dis->readFloat();
+		this->BoxDataA[i].fM = dis->readFloat();
+		this->BoxDataA[i].fS = dis->readFloat();
+	}
+	for(DWORD i=0;i<dwOffsetC;i++)
+	{
+		this->OffsetDataA[i].ePart = static_cast<eBodyOffset>(dis->readShort());
+		this->OffsetDataA[i].fD = dis->readFloat();
+		this->OffsetDataA[i].fO = dis->readFloat();
 	}
 }
 
-void TextureAndGeometryPacket::write(DataOutputStream *dos) //throws IOException
+void __fastcall TextureAndGeometryPacket::write(DataOutputStream *dos) //throws IOException
 {
 	dos->writeUTF(textureName);
 	dos->writeInt(dwSkinID);
@@ -203,6 +265,17 @@ void TextureAndGeometryPacket::write(DataOutputStream *dos) //throws IOException
 		dos->writeFloat(this->BoxDataA[i].fD);
 		dos->writeFloat(this->BoxDataA[i].fU);
 		dos->writeFloat(this->BoxDataA[i].fV);
+		dos->writeFloat(this->BoxDataA[i].fA);
+		dos->writeFloat(this->BoxDataA[i].fM);
+		dos->writeFloat(this->BoxDataA[i].fS);
+	}
+
+	dos->writeShort(static_cast<short>(dwOffsetC));
+	for(DWORD i=0;i<dwOffsetC;i++)
+	{
+		dos->writeShort(static_cast<short>(this->OffsetDataA[i].ePart));
+		dos->writeFloat(this->OffsetDataA[i].fD);
+		dos->writeFloat(this->OffsetDataA[i].fO);
 	}
 }
 

Minecraft.World/TextureAndGeometryPacket.h

@@ -4,6 +4,7 @@ using namespace std;
 #include "Packet.h"
 #include "../Minecraft.Client/Model.h"
 #include "../Minecraft.Client/SkinBox.h"
+#include "../Minecraft.Client/SkinOffset.h"
 
 class DLCSkinFile;
 
@@ -15,14 +16,16 @@ public:
 	PBYTE pbData;
 	DWORD dwTextureBytes;
 	SKIN_BOX *BoxDataA;
+	SKIN_OFFSET *OffsetDataA;
 	DWORD dwBoxC;
+	DWORD dwOffsetC;
 	unsigned int uiAnimOverrideBitmask;
 
 	TextureAndGeometryPacket();
 	~TextureAndGeometryPacket();
 	TextureAndGeometryPacket(const wstring &textureName, PBYTE pbData, DWORD dwBytes); 
 	TextureAndGeometryPacket(const wstring &textureName, PBYTE pbData, DWORD dwBytes, DLCSkinFile *pDLCSkinFile); 
-	TextureAndGeometryPacket(const wstring &textureName, PBYTE pbData, DWORD dwBytes, vector<SKIN_BOX *> *pvSkinBoxes, unsigned int uiAnimOverrideBitmask); 
+	TextureAndGeometryPacket(const wstring &textureName, PBYTE pbData, DWORD dwBytes, vector<SKIN_BOX *> *pvSkinBoxes, vector<SKIN_OFFSET *> *pvSkinOffsets, unsigned int uiAnimOverrideBitmask); 
 
 	virtual void handle(PacketListener *listener);
 	virtual void read(DataInputStream *dis);