Update old names to newer ones (#305)JackMaster

* JointKey -> LegacyJointKey

* CamData -> BgCamInfo

* TransformData -> CurveInterpKnot

* TransformUpdateIndex -> CurveAnimationHeader

* SkelCurveLimbList -> CurveSkeletonHeader

* LightSettings -> EnvLightSettings

* EntranceEntry -> Spawn

* PolygonDlist -> RoomShapeDListsEntry

* PolygonType0 -> RoomShapeNormal,
MeshHeader1Single -> RoomShapeImageSingle

* BgImage -> RoomShapeImageMultiBgEntry

* MeshHeader1Multi -> RoomShapeImageMulti
PolygonDlist2 -> RoomShapeCullableEntry

* PolygonType2 -> RoomShapeCullable

* SCENE_CMD_MESH -> SCENE_CMD_ROOM_SHAPE

* implement enum parsing + use NaviQuestHintFileId

* Struct_800A57C0 -> SkinVertex

* Struct_800A598C_2 -> SkinTransformation

* Struct_800A5E28 -> SkinAnimatedLimbData

* Struct_800A598C -> SkinLimbModif

* fix MM issues

* LinkAnimationHeader -> PlayerAnimationHeader (MM)

* CsCameraEntry -> ActorCsCamInfo (MM)

* remaining scene commands (MM)

* format

* removed useless comment

* name skinlimb members

* format

* fixed indentation

4 files changed, 201 insertions, 201 deletions

diff --git a/ZAPD/OtherStructs/CutsceneMM_Commands.cpp b/ZAPD/OtherStructs/CutsceneMM_Commands.cpp
index f0bd68a..85fce22 100644
--- a/ZAPD/OtherStructs/CutsceneMM_Commands.cpp
+++ b/ZAPD/OtherStructs/CutsceneMM_Commands.cpp
@@ -37,7 +37,7 @@ CutsceneMMSubCommandEntry_GenericCmd::CutsceneMMSubCommandEntry_GenericCmd(
 
 std::string CutsceneMMSubCommandEntry_GenericCmd::GetBodySourceCode() const
 {
-	CutsceneEnumData* cutsceneData = &Globals::Instance->cfg.cutsceneData;
+	EnumData* enumData = &Globals::Instance->cfg.enumData;
 	const auto& element = csCommandsDescMM.find(commandId);
 	std::string entryFmt = "CS_UNK_DATA(0x%02X, %i, %i, %i)";
 	std::string type = "";
@@ -49,29 +49,28 @@ std::string CutsceneMMSubCommandEntry_GenericCmd::GetBodySourceCode() const
 	}
 
 	if (commandId == CutsceneMM_CommandType::CS_CMD_MISC &&
-	    cutsceneData->miscType.find(base) != cutsceneData->miscType.end())
-		type = cutsceneData->miscType[base];
+	    enumData->miscType.find(base) != enumData->miscType.end())
+		type = enumData->miscType[base];
 
 	else if (commandId == CutsceneMM_CommandType::CS_CMD_TRANSITION &&
-	    cutsceneData->transitionType.find(base) != cutsceneData->transitionType.end())
-		type = cutsceneData->transitionType[base];
+	         enumData->transitionType.find(base) != enumData->transitionType.end())
+		type = enumData->transitionType[base];
 
 	else if (commandId == CutsceneMM_CommandType::CS_CMD_MOTION_BLUR &&
-	    cutsceneData->motionBlurType.find(base) != cutsceneData->motionBlurType.end())
-		type = cutsceneData->motionBlurType[base];
+	         enumData->motionBlurType.find(base) != enumData->motionBlurType.end())
+		type = enumData->motionBlurType[base];
 
 	else if (commandId == CutsceneMM_CommandType::CS_CMD_MODIFY_SEQ &&
-	    cutsceneData->modifySeqType.find(base) != cutsceneData->modifySeqType.end())
-		type = cutsceneData->modifySeqType[base];
+	         enumData->modifySeqType.find(base) != enumData->modifySeqType.end())
+		type = enumData->modifySeqType[base];
 
 	else if (commandId == CutsceneMM_CommandType::CS_CMD_DESTINATION &&
-	    cutsceneData->destinationType.find(base) != cutsceneData->destinationType.end())
-		type = cutsceneData->destinationType[base];
+	         enumData->destinationType.find(base) != enumData->destinationType.end())
+		type = enumData->destinationType[base];
 
 	else if (commandId == CutsceneMM_CommandType::CS_CMD_CHOOSE_CREDITS_SCENES &&
-	    cutsceneData->chooseCreditsSceneType.find(base) !=
-	        cutsceneData->chooseCreditsSceneType.end())
-		type = cutsceneData->chooseCreditsSceneType[base];
+	         enumData->chooseCreditsSceneType.find(base) != enumData->chooseCreditsSceneType.end())
+		type = enumData->chooseCreditsSceneType[base];
 
 	else if (commandId == CutsceneMM_CommandType::CS_CMD_GIVE_TATL)
 		type = base ? "true" : "false";
@@ -173,11 +172,11 @@ CutsceneSubCommandEntry_TransitionGeneral::CutsceneSubCommandEntry_TransitionGen
 
 std::string CutsceneSubCommandEntry_TransitionGeneral::GetBodySourceCode() const
 {
-	CutsceneEnumData* cutsceneData = &Globals::Instance->cfg.cutsceneData;
+	EnumData* enumData = &Globals::Instance->cfg.enumData;
 
-	if (cutsceneData->transitionGeneralType.find(base) != cutsceneData->transitionGeneralType.end())
+	if (enumData->transitionGeneralType.find(base) != enumData->transitionGeneralType.end())
 		return StringHelper::Sprintf("CS_TRANSITION_GENERAL(%s, %i, %i, %i, %i, %i)",
-		                             cutsceneData->transitionGeneralType[base].c_str(), startFrame,
+		                             enumData->transitionGeneralType[base].c_str(), startFrame,
 		                             endFrame, unk_06, unk_07, unk_08);
 
 	return StringHelper::Sprintf("CS_TRANSITION_GENERAL(0x%02X, %i, %i, %i, %i, %i)", base,
@@ -220,11 +219,11 @@ CutsceneSubCommandEntry_FadeOutSeq::CutsceneSubCommandEntry_FadeOutSeq(
 
 std::string CutsceneSubCommandEntry_FadeOutSeq::GetBodySourceCode() const
 {
-	CutsceneEnumData* cutsceneData = &Globals::Instance->cfg.cutsceneData;
+	EnumData* enumData = &Globals::Instance->cfg.enumData;
 
-	if (cutsceneData->fadeOutSeqPlayer.find(base) != cutsceneData->fadeOutSeqPlayer.end())
+	if (enumData->fadeOutSeqPlayer.find(base) != enumData->fadeOutSeqPlayer.end())
 		return StringHelper::Sprintf("CS_FADE_OUT_SEQ(%s, %i, %i)",
-		                             cutsceneData->fadeOutSeqPlayer[base].c_str(), startFrame,
+		                             enumData->fadeOutSeqPlayer[base].c_str(), startFrame,
 		                             endFrame);
 
 	return StringHelper::Sprintf("CS_FADE_OUT_SEQ(%i, %i, %i)", base, startFrame, endFrame);
@@ -291,11 +290,11 @@ CutsceneMMSubCommandEntry_Rumble::CutsceneMMSubCommandEntry_Rumble(
 
 std::string CutsceneMMSubCommandEntry_Rumble::GetBodySourceCode() const
 {
-	CutsceneEnumData* cutsceneData = &Globals::Instance->cfg.cutsceneData;
+	EnumData* enumData = &Globals::Instance->cfg.enumData;
 
-	if (cutsceneData->rumbleType.find(base) != cutsceneData->rumbleType.end())
+	if (enumData->rumbleType.find(base) != enumData->rumbleType.end())
 		return StringHelper::Sprintf("CS_RUMBLE(%s, %i, %i, 0x%02X, 0x%02X, 0x%02X)",
-		                             cutsceneData->rumbleType[base].c_str(), startFrame, endFrame,
+		                             enumData->rumbleType[base].c_str(), startFrame, endFrame,
 		                             intensity, decayTimer, decayStep);
 
 	return StringHelper::Sprintf("CS_RUMBLE(0x%04X, %i, %i, 0x%02X, 0x%02X, 0x%02X)", base,
@@ -467,17 +466,17 @@ CutsceneMMCommand_ActorCue::CutsceneMMCommand_ActorCue(const std::vector<uint8_t
 
 std::string CutsceneMMCommand_ActorCue::GetCommandMacro() const
 {
-	CutsceneEnumData* cutsceneData = &Globals::Instance->cfg.cutsceneData;
+	EnumData* enumData = &Globals::Instance->cfg.enumData;
 
 	if (static_cast<CutsceneMM_CommandType>(commandID) == CutsceneMM_CommandType::CS_CMD_PLAYER_CUE)
 	{
 		return StringHelper::Sprintf("CS_PLAYER_CUE_LIST(%i)", numEntries);
 	}
 
-	if (cutsceneData->cutsceneCmd.find(commandID) != cutsceneData->cutsceneCmd.end())
+	if (enumData->cutsceneCmd.find(commandID) != enumData->cutsceneCmd.end())
 	{
 		return StringHelper::Sprintf("CS_ACTOR_CUE_LIST(%s, %i)",
-		                             cutsceneData->cutsceneCmd[commandID].c_str(), numEntries);
+		                             enumData->cutsceneCmd[commandID].c_str(), numEntries);
 	}
 	return StringHelper::Sprintf("CS_ACTOR_CUE_LIST(0x%03X, %i)", commandID, numEntries);
 }
diff --git a/ZAPD/OtherStructs/CutsceneOoT_Commands.cpp b/ZAPD/OtherStructs/CutsceneOoT_Commands.cpp
index 367be0e..e38bfb6 100644
--- a/ZAPD/OtherStructs/CutsceneOoT_Commands.cpp
+++ b/ZAPD/OtherStructs/CutsceneOoT_Commands.cpp
@@ -43,22 +43,22 @@ CutsceneOoTSubCommandEntry_GenericCmd::CutsceneOoTSubCommandEntry_GenericCmd(
 
 std::string CutsceneOoTSubCommandEntry_GenericCmd::GetBodySourceCode() const
 {
-	CutsceneEnumData* cutsceneData = &Globals::Instance->cfg.cutsceneData;
+	EnumData* enumData = &Globals::Instance->cfg.enumData;
 	const auto& element = csCommandsDesc.find(commandId);
 
 	if (element != csCommandsDesc.end())
 	{
-		bool isIndexInMisc = cutsceneData->miscType.find(base) != cutsceneData->miscType.end();
+		bool isIndexInMisc = enumData->miscType.find(base) != enumData->miscType.end();
 		bool isIndexInFade =
-			cutsceneData->fadeOutSeqPlayer.find(base) != cutsceneData->fadeOutSeqPlayer.end();
+			enumData->fadeOutSeqPlayer.find(base) != enumData->fadeOutSeqPlayer.end();
 		std::string entryFmt = element->second.cmdMacro;
 		std::string firstArg;
 		entryFmt += element->second.args;
 
 		if (commandId == CutsceneOoT_CommandType::CS_CMD_MISC && isIndexInMisc)
-			firstArg = cutsceneData->miscType[base];
+			firstArg = enumData->miscType[base];
 		else if (commandId == CutsceneOoT_CommandType::CS_CMD_FADE_OUT_SEQ && isIndexInFade)
-			firstArg = cutsceneData->fadeOutSeqPlayer[base];
+			firstArg = enumData->fadeOutSeqPlayer[base];
 		else
 		{
 			bool baseOne = (commandId == CutsceneOoT_CommandType::CS_CMD_LIGHT_SETTING ||
@@ -264,7 +264,7 @@ CutsceneOoTSubCommandEntry_Text::CutsceneOoTSubCommandEntry_Text(
 
 std::string CutsceneOoTSubCommandEntry_Text::GetBodySourceCode() const
 {
-	CutsceneEnumData* cutsceneData = &Globals::Instance->cfg.cutsceneData;
+	EnumData* enumData = &Globals::Instance->cfg.enumData;
 
 	if (type == 0xFFFF)
 	{
@@ -276,11 +276,10 @@ std::string CutsceneOoTSubCommandEntry_Text::GetBodySourceCode() const
 		                             endFrame, textId1);
 	}
 
-	if (cutsceneData->textType.find(type) != cutsceneData->textType.end())
+	if (enumData->textType.find(type) != enumData->textType.end())
 	{
 		return StringHelper::Sprintf("CS_TEXT(0x%X, %i, %i, %s, 0x%X, 0x%X)", base, startFrame,
-		                             endFrame, cutsceneData->textType[type].c_str(), textId1,
-		                             textId2);
+		                             endFrame, enumData->textType[type].c_str(), textId1, textId2);
 	}
 
 	return StringHelper::Sprintf("CS_TEXT(0x%X, %i, %i, %i, 0x%X, 0x%X)", base, startFrame,
@@ -376,7 +375,7 @@ CutsceneOoTCommand_ActorCue::CutsceneOoTCommand_ActorCue(const std::vector<uint8
 
 std::string CutsceneOoTCommand_ActorCue::GetCommandMacro() const
 {
-	CutsceneEnumData* cutsceneData = &Globals::Instance->cfg.cutsceneData;
+	EnumData* enumData = &Globals::Instance->cfg.enumData;
 
 	if (static_cast<CutsceneOoT_CommandType>(commandID) ==
 	    CutsceneOoT_CommandType::CS_CMD_PLAYER_CUE)
@@ -384,10 +383,10 @@ std::string CutsceneOoTCommand_ActorCue::GetCommandMacro() const
 		return StringHelper::Sprintf("CS_PLAYER_CUE_LIST(%i)", entries.size());
 	}
 
-	if (cutsceneData->cutsceneCmd.find(commandID) != cutsceneData->cutsceneCmd.end())
+	if (enumData->cutsceneCmd.find(commandID) != enumData->cutsceneCmd.end())
 	{
 		return StringHelper::Sprintf("CS_ACTOR_CUE_LIST(%s, %i)",
-		                             cutsceneData->cutsceneCmd[commandID].c_str(), entries.size());
+		                             enumData->cutsceneCmd[commandID].c_str(), entries.size());
 	}
 
 	return StringHelper::Sprintf("CS_ACTOR_CUE_LIST(0x%04X, %i)", commandID, entries.size());
@@ -409,12 +408,12 @@ CutsceneOoTCommand_Destination::CutsceneOoTCommand_Destination(const std::vector
 
 std::string CutsceneOoTCommand_Destination::GenerateSourceCode() const
 {
-	CutsceneEnumData* cutsceneData = &Globals::Instance->cfg.cutsceneData;
+	EnumData* enumData = &Globals::Instance->cfg.enumData;
 
-	if (cutsceneData->destination.find(base) != cutsceneData->destination.end())
+	if (enumData->destination.find(base) != enumData->destination.end())
 	{
 		return StringHelper::Sprintf("CS_DESTINATION(%s, %i, %i),\n",
-		                             cutsceneData->destination[base].c_str(), startFrame, endFrame);
+		                             enumData->destination[base].c_str(), startFrame, endFrame);
 	}
 
 	return StringHelper::Sprintf("CS_DESTINATION(%i, %i, %i),\n", base, startFrame, endFrame);
@@ -440,13 +439,12 @@ CutsceneOoTCommand_Transition::CutsceneOoTCommand_Transition(const std::vector<u
 
 std::string CutsceneOoTCommand_Transition::GenerateSourceCode() const
 {
-	CutsceneEnumData* cutsceneData = &Globals::Instance->cfg.cutsceneData;
+	EnumData* enumData = &Globals::Instance->cfg.enumData;
 
-	if (cutsceneData->transitionType.find(base) != cutsceneData->transitionType.end())
+	if (enumData->transitionType.find(base) != enumData->transitionType.end())
 	{
 		return StringHelper::Sprintf("CS_TRANSITION(%s, %i, %i),\n",
-		                             cutsceneData->transitionType[base].c_str(), startFrame,
-		                             endFrame);
+		                             enumData->transitionType[base].c_str(), startFrame, endFrame);
 	}
 
 	return StringHelper::Sprintf("CS_TRANSITION(%i, %i, %i),\n", base, startFrame, endFrame);
diff --git a/ZAPD/OtherStructs/SkinLimbStructs.cpp b/ZAPD/OtherStructs/SkinLimbStructs.cpp
index 4c12062..e85bdef 100644
--- a/ZAPD/OtherStructs/SkinLimbStructs.cpp
+++ b/ZAPD/OtherStructs/SkinLimbStructs.cpp
@@ -6,149 +6,149 @@
 #include "ZDisplayList.h"
 #include "ZFile.h"
 
-/* Struct_800A57C0 */
+/* SkinVertex */
 
-Struct_800A57C0::Struct_800A57C0(ZFile* nParent) : ZResource(nParent)
+SkinVertex::SkinVertex(ZFile* nParent) : ZResource(nParent)
 {
 }
 
-void Struct_800A57C0::ParseRawData()
+void SkinVertex::ParseRawData()
 {
 	const auto& rawData = parent->GetRawData();
 
-	unk_0 = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0x00);
-	unk_2 = BitConverter::ToInt16BE(rawData, rawDataIndex + 0x02);
-	unk_4 = BitConverter::ToInt16BE(rawData, rawDataIndex + 0x04);
-	unk_6 = BitConverter::ToInt8BE(rawData, rawDataIndex + 0x06);
-	unk_7 = BitConverter::ToInt8BE(rawData, rawDataIndex + 0x07);
-	unk_8 = BitConverter::ToInt8BE(rawData, rawDataIndex + 0x08);
-	unk_9 = BitConverter::ToUInt8BE(rawData, rawDataIndex + 0x09);
+	index = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0x00);
+	s = BitConverter::ToInt16BE(rawData, rawDataIndex + 0x02);
+	t = BitConverter::ToInt16BE(rawData, rawDataIndex + 0x04);
+	normX = BitConverter::ToInt8BE(rawData, rawDataIndex + 0x06);
+	normY = BitConverter::ToInt8BE(rawData, rawDataIndex + 0x07);
+	normZ = BitConverter::ToInt8BE(rawData, rawDataIndex + 0x08);
+	alpha = BitConverter::ToUInt8BE(rawData, rawDataIndex + 0x09);
 }
 
-std::string Struct_800A57C0::GetBodySourceCode() const
+std::string SkinVertex::GetBodySourceCode() const
 {
-	return StringHelper::Sprintf("0x%02X, %i, %i, %i, %i, %i, 0x%02X", unk_0, unk_2, unk_4, unk_6,
-	                             unk_7, unk_8, unk_9);
+	return StringHelper::Sprintf("0x%02X, %i, %i, %i, %i, %i, 0x%02X", index, s, t, normX, normY,
+	                             normZ, alpha);
 }
 
-std::string Struct_800A57C0::GetSourceTypeName() const
+std::string SkinVertex::GetSourceTypeName() const
 {
-	return "Struct_800A57C0";
+	return "SkinVertex";
 }
 
-ZResourceType Struct_800A57C0::GetResourceType() const
+ZResourceType SkinVertex::GetResourceType() const
 {
 	// TODO
 	return ZResourceType::Error;
 }
 
-size_t Struct_800A57C0::GetRawDataSize() const
+size_t SkinVertex::GetRawDataSize() const
 {
 	return 0x0A;
 }
 
-/* Struct_800A598C_2 */
+/* SkinTransformation */
 
-Struct_800A598C_2::Struct_800A598C_2(ZFile* nParent) : ZResource(nParent)
+SkinTransformation::SkinTransformation(ZFile* nParent) : ZResource(nParent)
 {
 }
 
-void Struct_800A598C_2::ParseRawData()
+void SkinTransformation::ParseRawData()
 {
 	const auto& rawData = parent->GetRawData();
 
-	unk_0 = BitConverter::ToUInt8BE(rawData, rawDataIndex + 0x00);
+	limbIndex = BitConverter::ToUInt8BE(rawData, rawDataIndex + 0x00);
 	x = BitConverter::ToInt16BE(rawData, rawDataIndex + 0x02);
 	y = BitConverter::ToInt16BE(rawData, rawDataIndex + 0x04);
 	z = BitConverter::ToInt16BE(rawData, rawDataIndex + 0x06);
-	unk_8 = BitConverter::ToUInt8BE(rawData, rawDataIndex + 0x08);
+	scale = BitConverter::ToUInt8BE(rawData, rawDataIndex + 0x08);
 }
 
-std::string Struct_800A598C_2::GetBodySourceCode() const
+std::string SkinTransformation::GetBodySourceCode() const
 {
-	return StringHelper::Sprintf("0x%02X, %i, %i, %i, 0x%02X", unk_0, x, y, z, unk_8);
+	return StringHelper::Sprintf("0x%02X, %i, %i, %i, 0x%02X", limbIndex, x, y, z, scale);
 }
 
-std::string Struct_800A598C_2::GetSourceTypeName() const
+std::string SkinTransformation::GetSourceTypeName() const
 {
-	return "Struct_800A598C_2";
+	return "SkinTransformation";
 }
 
-ZResourceType Struct_800A598C_2::GetResourceType() const
+ZResourceType SkinTransformation::GetResourceType() const
 {
 	// TODO
 	return ZResourceType::Error;
 }
 
-size_t Struct_800A598C_2::GetRawDataSize() const
+size_t SkinTransformation::GetRawDataSize() const
 {
 	return 0x0A;
 }
 
-/* Struct_800A598C */
+/* SkinLimbModif */
 
-Struct_800A598C::Struct_800A598C(ZFile* nParent) : ZResource(nParent)
+SkinLimbModif::SkinLimbModif(ZFile* nParent) : ZResource(nParent)
 {
 }
 
-void Struct_800A598C::ParseRawData()
+void SkinLimbModif::ParseRawData()
 {
 	const auto& rawData = parent->GetRawData();
 
-	unk_0 = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0x00);
-	unk_2 = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0x02);
+	vtxCount = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0x00);
+	transformCount = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0x02);
 	unk_4 = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0x04);
-	unk_8 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 0x08);
-	unk_C = BitConverter::ToUInt32BE(rawData, rawDataIndex + 0x0C);
+	skinVertices = BitConverter::ToUInt32BE(rawData, rawDataIndex + 0x08);
+	limbTransformations = BitConverter::ToUInt32BE(rawData, rawDataIndex + 0x0C);
 
-	if (unk_8 != 0 && GETSEGNUM(unk_8) == parent->segment)
+	if (skinVertices != 0 && GETSEGNUM(skinVertices) == parent->segment)
 	{
-		uint32_t unk_8_Offset = Seg2Filespace(unk_8, parent->baseAddress);
+		uint32_t unk_8_Offset = Seg2Filespace(skinVertices, parent->baseAddress);
 
-		unk_8_arr.reserve(unk_0);
-		for (size_t i = 0; i < unk_0; i++)
+		skinVertices_arr.reserve(vtxCount);
+		for (size_t i = 0; i < vtxCount; i++)
 		{
-			Struct_800A57C0 unk8_data(parent);
-			unk8_data.ExtractFromFile(unk_8_Offset);
-			unk_8_arr.push_back(unk8_data);
+			SkinVertex skinVertices_data(parent);
+			skinVertices_data.ExtractFromFile(unk_8_Offset);
+			skinVertices_arr.push_back(skinVertices_data);
 
-			unk_8_Offset += unk8_data.GetRawDataSize();
+			unk_8_Offset += skinVertices_data.GetRawDataSize();
 		}
 	}
 
-	if (unk_C != 0 && GETSEGNUM(unk_8) == parent->segment)
+	if (limbTransformations != 0 && GETSEGNUM(skinVertices) == parent->segment)
 	{
-		uint32_t unk_C_Offset = Seg2Filespace(unk_C, parent->baseAddress);
+		uint32_t unk_C_Offset = Seg2Filespace(limbTransformations, parent->baseAddress);
 
-		unk_C_arr.reserve(unk_2);
-		for (size_t i = 0; i < unk_2; i++)
+		limbTransformations_arr.reserve(transformCount);
+		for (size_t i = 0; i < transformCount; i++)
 		{
-			Struct_800A598C_2 unkC_data(parent);
-			unkC_data.ExtractFromFile(unk_C_Offset);
-			unk_C_arr.push_back(unkC_data);
+			SkinTransformation limbTransformations_data(parent);
+			limbTransformations_data.ExtractFromFile(unk_C_Offset);
+			limbTransformations_arr.push_back(limbTransformations_data);
 
-			unk_C_Offset += unkC_data.GetRawDataSize();
+			unk_C_Offset += limbTransformations_data.GetRawDataSize();
 		}
 	}
 }
 
-void Struct_800A598C::DeclareReferences(const std::string& prefix)
+void SkinLimbModif::DeclareReferences(const std::string& prefix)
 {
 	std::string varPrefix = prefix;
 	if (name != "")
 		varPrefix = name;
 
-	if (unk_8 != 0 && GETSEGNUM(unk_8) == parent->segment)
+	if (skinVertices != 0 && GETSEGNUM(skinVertices) == parent->segment)
 	{
-		const auto& res = unk_8_arr.at(0);
+		const auto& res = skinVertices_arr.at(0);
 		std::string unk_8_Str = res.GetDefaultName(varPrefix);
 
-		size_t arrayItemCnt = unk_8_arr.size();
+		size_t arrayItemCnt = skinVertices_arr.size();
 		std::string entryStr = "";
 
 		for (size_t i = 0; i < arrayItemCnt; i++)
 		{
-			auto& child = unk_8_arr[i];
+			auto& child = skinVertices_arr[i];
 			child.DeclareReferences(varPrefix);
 			entryStr += StringHelper::Sprintf("\t{ %s },", child.GetBodySourceCode().c_str());
 
@@ -156,11 +156,11 @@ void Struct_800A598C::DeclareReferences(const std::string& prefix)
 				entryStr += "\n";
 		}
 
-		uint32_t unk_8_Offset = Seg2Filespace(unk_8, parent->baseAddress);
-		Declaration* decl = parent->GetDeclaration(unk_8_Offset);
+		uint32_t skinVertices_Offset = Seg2Filespace(skinVertices, parent->baseAddress);
+		Declaration* decl = parent->GetDeclaration(skinVertices_Offset);
 		if (decl == nullptr)
 		{
-			parent->AddDeclarationArray(unk_8_Offset, res.GetDeclarationAlignment(),
+			parent->AddDeclarationArray(skinVertices_Offset, res.GetDeclarationAlignment(),
 			                            arrayItemCnt * res.GetRawDataSize(),
 			                            res.GetSourceTypeName(), unk_8_Str, arrayItemCnt, entryStr);
 		}
@@ -168,17 +168,17 @@ void Struct_800A598C::DeclareReferences(const std::string& prefix)
 			decl->declBody = entryStr;
 	}
 
-	if (unk_C != 0 && GETSEGNUM(unk_C) == parent->segment)
+	if (limbTransformations != 0 && GETSEGNUM(limbTransformations) == parent->segment)
 	{
-		const auto& res = unk_C_arr.at(0);
+		const auto& res = limbTransformations_arr.at(0);
 		std::string unk_C_Str = res.GetDefaultName(varPrefix);
 
-		size_t arrayItemCnt = unk_C_arr.size();
+		size_t arrayItemCnt = limbTransformations_arr.size();
 		std::string entryStr = "";
 
 		for (size_t i = 0; i < arrayItemCnt; i++)
 		{
-			auto& child = unk_C_arr[i];
+			auto& child = limbTransformations_arr[i];
 			child.DeclareReferences(varPrefix);
 			entryStr += StringHelper::Sprintf("\t{ %s },", child.GetBodySourceCode().c_str());
 
@@ -186,7 +186,7 @@ void Struct_800A598C::DeclareReferences(const std::string& prefix)
 				entryStr += "\n";
 		}
 
-		uint32_t unk_C_Offset = Seg2Filespace(unk_C, parent->baseAddress);
+		uint32_t unk_C_Offset = Seg2Filespace(limbTransformations, parent->baseAddress);
 		Declaration* decl = parent->GetDeclaration(unk_C_Offset);
 		if (decl == nullptr)
 		{
@@ -199,69 +199,70 @@ void Struct_800A598C::DeclareReferences(const std::string& prefix)
 	}
 }
 
-std::string Struct_800A598C::GetBodySourceCode() const
+std::string SkinLimbModif::GetBodySourceCode() const
 {
-	std::string unk_8_Str;
+	std::string skinVertices_Str;
 	std::string unk_C_Str;
-	Globals::Instance->GetSegmentedPtrName(unk_8, parent, "Struct_800A57C0", unk_8_Str);
-	Globals::Instance->GetSegmentedPtrName(unk_C, parent, "Struct_800A598C_2", unk_C_Str);
+	Globals::Instance->GetSegmentedPtrName(skinVertices, parent, "SkinVertex", skinVertices_Str);
+	Globals::Instance->GetSegmentedPtrName(limbTransformations, parent, "SkinTransformation",
+	                                       unk_C_Str);
 
 	std::string entryStr = StringHelper::Sprintf("\n\t\tARRAY_COUNTU(%s), ARRAY_COUNTU(%s),\n",
-	                                             unk_8_Str.c_str(), unk_C_Str.c_str());
-	entryStr +=
-		StringHelper::Sprintf("\t\t%i, %s, %s\n\t", unk_4, unk_8_Str.c_str(), unk_C_Str.c_str());
+	                                             skinVertices_Str.c_str(), unk_C_Str.c_str());
+	entryStr += StringHelper::Sprintf("\t\t%i, %s, %s\n\t", unk_4, skinVertices_Str.c_str(),
+	                                  unk_C_Str.c_str());
 
 	return entryStr;
 }
 
-std::string Struct_800A598C::GetSourceTypeName() const
+std::string SkinLimbModif::GetSourceTypeName() const
 {
-	return "Struct_800A598C";
+	return "SkinLimbModif";
 }
 
-ZResourceType Struct_800A598C::GetResourceType() const
+ZResourceType SkinLimbModif::GetResourceType() const
 {
 	// TODO
 	return ZResourceType::Error;
 }
 
-size_t Struct_800A598C::GetRawDataSize() const
+size_t SkinLimbModif::GetRawDataSize() const
 {
 	return 0x10;
 }
 
-/* Struct_800A5E28 */
+/* SkinAnimatedLimbData */
 
-Struct_800A5E28::Struct_800A5E28(ZFile* nParent) : ZResource(nParent)
+SkinAnimatedLimbData::SkinAnimatedLimbData(ZFile* nParent) : ZResource(nParent)
 {
 }
 
-void Struct_800A5E28::ParseRawData()
+void SkinAnimatedLimbData::ParseRawData()
 {
 	const auto& rawData = parent->GetRawData();
 
-	unk_0 = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0x00);
-	unk_2 = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0x02);
-	unk_4 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 0x04);
-	unk_8 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 0x08);
+	totalVtxCount = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0x00);
+	limbModifCount = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0x02);
+	limbModifications = BitConverter::ToUInt32BE(rawData, rawDataIndex + 0x04);
+	dlist = BitConverter::ToUInt32BE(rawData, rawDataIndex + 0x08);
 
-	if (unk_4 != 0 && GETSEGNUM(unk_4) == parent->segment)
+	if (limbModifications != 0 && GETSEGNUM(limbModifications) == parent->segment)
 	{
-		uint32_t unk_4_Offset = Seg2Filespace(unk_4, parent->baseAddress);
+		uint32_t limbModifications_Offset = Seg2Filespace(limbModifications, parent->baseAddress);
 
-		unk_4_arr.reserve(unk_2);
-		for (size_t i = 0; i < unk_2; i++)
+		limbModifications_arr.reserve(limbModifCount);
+		for (size_t i = 0; i < limbModifCount; i++)
 		{
-			Struct_800A598C unk_4_data(parent);
-			unk_4_data.ExtractFromFile(unk_4_Offset);
-			unk_4_arr.push_back(unk_4_data);
+			SkinLimbModif limbModifications_data(parent);
+			limbModifications_data.ExtractFromFile(limbModifications_Offset);
+			limbModifications_arr.push_back(limbModifications_data);
 
-			unk_4_Offset += unk_4_data.GetRawDataSize();
+			limbModifications_Offset += limbModifications_data.GetRawDataSize();
 		}
 	}
 }
 
-void Struct_800A5E28::DeclareReferences(const std::string& prefix)
+void SkinAnimatedLimbData::DeclareReferences(const std::string& prefix)
 {
 	std::string varPrefix = prefix;
 	if (name != "")
@@ -269,17 +270,17 @@ void Struct_800A5E28::DeclareReferences(const std::string& prefix)
 
 	ZResource::DeclareReferences(varPrefix);
 
-	if (unk_4 != SEGMENTED_NULL && GETSEGNUM(unk_4) == parent->segment)
+	if (limbModifications != SEGMENTED_NULL && GETSEGNUM(limbModifications) == parent->segment)
 	{
-		const auto& res = unk_4_arr.at(0);
-		std::string unk_4_Str = res.GetDefaultName(varPrefix);
+		const auto& res = limbModifications_arr.at(0);
+		std::string limbModifications_Str = res.GetDefaultName(varPrefix);
 
-		size_t arrayItemCnt = unk_4_arr.size();
+		size_t arrayItemCnt = limbModifications_arr.size();
 		std::string entryStr = "";
 
 		for (size_t i = 0; i < arrayItemCnt; i++)
 		{
-			auto& child = unk_4_arr[i];
+			auto& child = limbModifications_arr[i];
 			child.DeclareReferences(varPrefix);
 			entryStr += StringHelper::Sprintf("\t{ %s },", child.GetBodySourceCode().c_str());
 
@@ -287,63 +288,67 @@ void Struct_800A5E28::DeclareReferences(const std::string& prefix)
 				entryStr += "\n";
 		}
 
-		uint32_t unk_4_Offset = Seg2Filespace(unk_4, parent->baseAddress);
-		Declaration* decl = parent->GetDeclaration(unk_4_Offset);
+		uint32_t limbModifications_Offset = Seg2Filespace(limbModifications, parent->baseAddress);
+		Declaration* decl = parent->GetDeclaration(limbModifications_Offset);
 		if (decl == nullptr)
 		{
-			parent->AddDeclarationArray(unk_4_Offset, res.GetDeclarationAlignment(),
+			parent->AddDeclarationArray(limbModifications_Offset, res.GetDeclarationAlignment(),
 			                            arrayItemCnt * res.GetRawDataSize(),
-			                            res.GetSourceTypeName(), unk_4_Str, arrayItemCnt, entryStr);
+			                            res.GetSourceTypeName(), limbModifications_Str,
+			                            arrayItemCnt, entryStr);
 		}
 		else
 			decl->declBody = entryStr;
 	}
 
-	if (unk_8 != SEGMENTED_NULL && GETSEGNUM(unk_8) == parent->segment)
+	if (dlist != SEGMENTED_NULL && GETSEGNUM(dlist) == parent->segment)
 	{
-		uint32_t unk_8_Offset = Seg2Filespace(unk_8, parent->baseAddress);
+		uint32_t dlist_Offset = Seg2Filespace(dlist, parent->baseAddress);
 
 		int32_t dlistLength = ZDisplayList::GetDListLength(
-			parent->GetRawData(), unk_8_Offset,
+			parent->GetRawData(), dlist_Offset,
 			Globals::Instance->game == ZGame::OOT_SW97 ? DListType::F3DEX : DListType::F3DZEX);
-		ZDisplayList* unk_8_dlist = new ZDisplayList(parent);
-		unk_8_dlist->ExtractFromBinary(unk_8_Offset, dlistLength);
+		ZDisplayList* dlist_data = new ZDisplayList(parent);
+		dlist_data->ExtractFromBinary(dlist_Offset, dlistLength);
 
 		std::string dListStr =
-			StringHelper::Sprintf("%sSkinLimbDL_%06X", varPrefix.c_str(), unk_8_Offset);
-		unk_8_dlist->SetName(dListStr);
-		unk_8_dlist->DeclareVar(varPrefix, "");
-		unk_8_dlist->DeclareReferences(varPrefix);
-		parent->AddResource(unk_8_dlist);
+			StringHelper::Sprintf("%sSkinLimbDL_%06X", varPrefix.c_str(), dlist_Offset);
+		dlist_data->SetName(dListStr);
+		dlist_data->DeclareVar(varPrefix, "");
+		dlist_data->DeclareReferences(varPrefix);
+		parent->AddResource(dlist_data);
 	}
 }
 
-std::string Struct_800A5E28::GetBodySourceCode() const
+std::string SkinAnimatedLimbData::GetBodySourceCode() const
 {
-	std::string unk_4_Str;
-	std::string unk_8_Str;
-	Globals::Instance->GetSegmentedPtrName(unk_4, parent, "Struct_800A598C", unk_4_Str);
-	Globals::Instance->GetSegmentedPtrName(unk_8, parent, "Gfx", unk_8_Str);
+	std::string limbModifications_Str;
+	std::string dlist_Str;
+	Globals::Instance->GetSegmentedPtrName(limbModifications, parent, "SkinLimbModif",
+	                                       limbModifications_Str);
+	Globals::Instance->GetSegmentedPtrName(dlist, parent, "Gfx", dlist_Str);
 
 	std::string entryStr = "\n";
-	entryStr += StringHelper::Sprintf("\t%i, ARRAY_COUNTU(%s),\n", unk_0, unk_4_Str.c_str());
-	entryStr += StringHelper::Sprintf("\t%s, %s\n", unk_4_Str.c_str(), unk_8_Str.c_str());
+	entryStr += StringHelper::Sprintf("\t%i, ARRAY_COUNTU(%s),\n", totalVtxCount,
+	                                  limbModifications_Str.c_str());
+	entryStr +=
+		StringHelper::Sprintf("\t%s, %s\n", limbModifications_Str.c_str(), dlist_Str.c_str());
 
 	return entryStr;
 }
 
-std::string Struct_800A5E28::GetSourceTypeName() const
+std::string SkinAnimatedLimbData::GetSourceTypeName() const
 {
-	return "Struct_800A5E28";
+	return "SkinAnimatedLimbData";
 }
 
-ZResourceType Struct_800A5E28::GetResourceType() const
+ZResourceType SkinAnimatedLimbData::GetResourceType() const
 {
 	// TODO
 	return ZResourceType::Error;
 }
 
-size_t Struct_800A5E28::GetRawDataSize() const
+size_t SkinAnimatedLimbData::GetRawDataSize() const
 {
 	return 0x0C;
 }
diff --git a/ZAPD/OtherStructs/SkinLimbStructs.h b/ZAPD/OtherStructs/SkinLimbStructs.h
index 33edd07..5181bc5 100644
--- a/ZAPD/OtherStructs/SkinLimbStructs.h
+++ b/ZAPD/OtherStructs/SkinLimbStructs.h
@@ -6,19 +6,17 @@
 
 #include "ZResource.h"
 
-// TODO: check if more types exists
 enum class ZLimbSkinType
 {
-	SkinType_0,           // Segment = 0
-	SkinType_4 = 4,       // Segment = segmented address // Struct_800A5E28
-	SkinType_5 = 5,       // Segment = 0
-	SkinType_DList = 11,  // Segment = DList address
+	SkinType_Null,			// SkinLimb segment = NULL
+	SkinType_Animated = 4,	// SkinLimb segment = SkinAnimatedLimbData*
+	SkinType_Normal = 11,	// SkinLimb segment = Gfx*
 };
 
-class Struct_800A57C0 : public ZResource
+class SkinVertex : public ZResource
 {
 public:
-	Struct_800A57C0(ZFile* nParent);
+	SkinVertex(ZFile* nParent);
 
 	void ParseRawData() override;
 
@@ -30,19 +28,19 @@ public:
 	size_t GetRawDataSize() const override;
 
 protected:
-	uint16_t unk_0;
-	int16_t unk_2;
-	int16_t unk_4;
-	int8_t unk_6;
-	int8_t unk_7;
-	int8_t unk_8;
-	uint8_t unk_9;
+	uint16_t index;
+	int16_t s;
+	int16_t t;
+	int8_t normX;
+	int8_t normY;
+	int8_t normZ;
+	uint8_t alpha;
 };
 
-class Struct_800A598C_2 : public ZResource
+class SkinTransformation : public ZResource
 {
 public:
-	Struct_800A598C_2(ZFile* nParent);
+	SkinTransformation(ZFile* nParent);
 
 	void ParseRawData() override;
 
@@ -54,17 +52,17 @@ public:
 	size_t GetRawDataSize() const override;
 
 protected:
-	uint8_t unk_0;
+	uint8_t limbIndex;
 	int16_t x;
 	int16_t y;
 	int16_t z;
-	uint8_t unk_8;
+	uint8_t scale;
 };
 
-class Struct_800A598C : public ZResource
+class SkinLimbModif : public ZResource
 {
 public:
-	Struct_800A598C(ZFile* nParent);
+	SkinLimbModif(ZFile* nParent);
 
 	void ParseRawData() override;
 	void DeclareReferences(const std::string& prefix) override;
@@ -77,20 +75,20 @@ public:
 	size_t GetRawDataSize() const override;
 
 protected:
-	uint16_t unk_0;  // Length of unk_8
-	uint16_t unk_2;  // Length of unk_C
-	uint16_t unk_4;  // 0 or 1 // Used as an index for unk_C
-	segptr_t unk_8;  // Struct_800A57C0*
-	segptr_t unk_C;  // Struct_800A598C_2*
-
-	std::vector<Struct_800A57C0> unk_8_arr;
-	std::vector<Struct_800A598C_2> unk_C_arr;
+	uint16_t vtxCount;				// Number of vertices in this modif entry
+	uint16_t transformCount;		// Length of limbTransformations
+	uint16_t unk_4;					// 0 or 1, used as an index for limbTransformations
+	segptr_t skinVertices;			// SkinVertex*
+	segptr_t limbTransformations;	// SkinTransformation*
+
+	std::vector<SkinVertex> skinVertices_arr;
+	std::vector<SkinTransformation> limbTransformations_arr;
 };
 
-class Struct_800A5E28 : public ZResource
+class SkinAnimatedLimbData : public ZResource
 {
 public:
-	Struct_800A5E28(ZFile* nParent);
+	SkinAnimatedLimbData(ZFile* nParent);
 
 	void ParseRawData() override;
 	void DeclareReferences(const std::string& prefix) override;
@@ -103,11 +101,11 @@ public:
 	size_t GetRawDataSize() const override;
 
 protected:
-	uint16_t unk_0;  // Vtx count
-	uint16_t unk_2;  // Length of unk_4
-	segptr_t unk_4;  // Struct_800A598C*
-	segptr_t unk_8;  // Gfx*
+	uint16_t totalVtxCount;
+	uint16_t limbModifCount;	// Length of limbModifications
+	segptr_t limbModifications;	// SkinLimbModif*
+	segptr_t dlist;				// Gfx*
 
-	std::vector<Struct_800A598C> unk_4_arr;
+	std::vector<SkinLimbModif> limbModifications_arr;
 	// ZDisplayList* unk_8_dlist = nullptr;
 };