mirror of
https://github.com/zeldaret/oot.git
synced 2025-08-14 11:00:41 +00:00
4e55168eaa
* git subrepo pull --force tools/ZAPD subrepo: subdir: "tools/ZAPD" merged: "094e79734" upstream: origin: "https://github.com/zeldaret/ZAPD.git" branch: "master" commit: "094e79734" git-subrepo: version: "0.4.6" origin: "https://github.com/ingydotnet/git-subrepo" commit: "110b9eb" * Add EnumData.xml where some names are now externalized * Remove legacy typedefs for zapd, no longer needed!
354 lines
10 KiB
C++
354 lines
10 KiB
C++
#include "SkinLimbStructs.h"
|
|
|
|
#include "Globals.h"
|
|
#include "Utils/BitConverter.h"
|
|
#include "Utils/StringHelper.h"
|
|
#include "ZDisplayList.h"
|
|
#include "ZFile.h"
|
|
|
|
/* SkinVertex */
|
|
|
|
SkinVertex::SkinVertex(ZFile* nParent) : ZResource(nParent)
|
|
{
|
|
}
|
|
|
|
void SkinVertex::ParseRawData()
|
|
{
|
|
const auto& rawData = parent->GetRawData();
|
|
|
|
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 SkinVertex::GetBodySourceCode() const
|
|
{
|
|
return StringHelper::Sprintf("0x%02X, %i, %i, %i, %i, %i, 0x%02X", index, s, t, normX, normY,
|
|
normZ, alpha);
|
|
}
|
|
|
|
std::string SkinVertex::GetSourceTypeName() const
|
|
{
|
|
return "SkinVertex";
|
|
}
|
|
|
|
ZResourceType SkinVertex::GetResourceType() const
|
|
{
|
|
// TODO
|
|
return ZResourceType::Error;
|
|
}
|
|
|
|
size_t SkinVertex::GetRawDataSize() const
|
|
{
|
|
return 0x0A;
|
|
}
|
|
|
|
/* SkinTransformation */
|
|
|
|
SkinTransformation::SkinTransformation(ZFile* nParent) : ZResource(nParent)
|
|
{
|
|
}
|
|
|
|
void SkinTransformation::ParseRawData()
|
|
{
|
|
const auto& rawData = parent->GetRawData();
|
|
|
|
limbIndex = BitConverter::ToUInt8BE(rawData, rawDataIndex + 0x00);
|
|
x = BitConverter::ToInt16BE(rawData, rawDataIndex + 0x02);
|
|
y = BitConverter::ToInt16BE(rawData, rawDataIndex + 0x04);
|
|
z = BitConverter::ToInt16BE(rawData, rawDataIndex + 0x06);
|
|
scale = BitConverter::ToUInt8BE(rawData, rawDataIndex + 0x08);
|
|
}
|
|
|
|
std::string SkinTransformation::GetBodySourceCode() const
|
|
{
|
|
return StringHelper::Sprintf("0x%02X, %i, %i, %i, 0x%02X", limbIndex, x, y, z, scale);
|
|
}
|
|
|
|
std::string SkinTransformation::GetSourceTypeName() const
|
|
{
|
|
return "SkinTransformation";
|
|
}
|
|
|
|
ZResourceType SkinTransformation::GetResourceType() const
|
|
{
|
|
// TODO
|
|
return ZResourceType::Error;
|
|
}
|
|
|
|
size_t SkinTransformation::GetRawDataSize() const
|
|
{
|
|
return 0x0A;
|
|
}
|
|
|
|
/* SkinLimbModif */
|
|
|
|
SkinLimbModif::SkinLimbModif(ZFile* nParent) : ZResource(nParent)
|
|
{
|
|
}
|
|
|
|
void SkinLimbModif::ParseRawData()
|
|
{
|
|
const auto& rawData = parent->GetRawData();
|
|
|
|
vtxCount = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0x00);
|
|
transformCount = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0x02);
|
|
unk_4 = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0x04);
|
|
skinVertices = BitConverter::ToUInt32BE(rawData, rawDataIndex + 0x08);
|
|
limbTransformations = BitConverter::ToUInt32BE(rawData, rawDataIndex + 0x0C);
|
|
|
|
if (skinVertices != 0 && GETSEGNUM(skinVertices) == parent->segment)
|
|
{
|
|
uint32_t unk_8_Offset = Seg2Filespace(skinVertices, parent->baseAddress);
|
|
|
|
skinVertices_arr.reserve(vtxCount);
|
|
for (size_t i = 0; i < vtxCount; i++)
|
|
{
|
|
SkinVertex skinVertices_data(parent);
|
|
skinVertices_data.ExtractFromFile(unk_8_Offset);
|
|
skinVertices_arr.push_back(skinVertices_data);
|
|
|
|
unk_8_Offset += skinVertices_data.GetRawDataSize();
|
|
}
|
|
}
|
|
|
|
if (limbTransformations != 0 && GETSEGNUM(skinVertices) == parent->segment)
|
|
{
|
|
uint32_t unk_C_Offset = Seg2Filespace(limbTransformations, parent->baseAddress);
|
|
|
|
limbTransformations_arr.reserve(transformCount);
|
|
for (size_t i = 0; i < transformCount; i++)
|
|
{
|
|
SkinTransformation limbTransformations_data(parent);
|
|
limbTransformations_data.ExtractFromFile(unk_C_Offset);
|
|
limbTransformations_arr.push_back(limbTransformations_data);
|
|
|
|
unk_C_Offset += limbTransformations_data.GetRawDataSize();
|
|
}
|
|
}
|
|
}
|
|
|
|
void SkinLimbModif::DeclareReferences(const std::string& prefix)
|
|
{
|
|
std::string varPrefix = prefix;
|
|
if (name != "")
|
|
varPrefix = name;
|
|
|
|
if (skinVertices != 0 && GETSEGNUM(skinVertices) == parent->segment)
|
|
{
|
|
const auto& res = skinVertices_arr.at(0);
|
|
std::string unk_8_Str = res.GetDefaultName(varPrefix);
|
|
|
|
size_t arrayItemCnt = skinVertices_arr.size();
|
|
std::string entryStr = "";
|
|
|
|
for (size_t i = 0; i < arrayItemCnt; i++)
|
|
{
|
|
auto& child = skinVertices_arr[i];
|
|
child.DeclareReferences(varPrefix);
|
|
entryStr += StringHelper::Sprintf("\t{ %s },", child.GetBodySourceCode().c_str());
|
|
|
|
if (i < arrayItemCnt - 1)
|
|
entryStr += "\n";
|
|
}
|
|
|
|
uint32_t skinVertices_Offset = Seg2Filespace(skinVertices, parent->baseAddress);
|
|
Declaration* decl = parent->GetDeclaration(skinVertices_Offset);
|
|
if (decl == nullptr)
|
|
{
|
|
parent->AddDeclarationArray(skinVertices_Offset, res.GetDeclarationAlignment(),
|
|
arrayItemCnt * res.GetRawDataSize(),
|
|
res.GetSourceTypeName(), unk_8_Str, arrayItemCnt, entryStr);
|
|
}
|
|
else
|
|
decl->declBody = entryStr;
|
|
}
|
|
|
|
if (limbTransformations != 0 && GETSEGNUM(limbTransformations) == parent->segment)
|
|
{
|
|
const auto& res = limbTransformations_arr.at(0);
|
|
std::string unk_C_Str = res.GetDefaultName(varPrefix);
|
|
|
|
size_t arrayItemCnt = limbTransformations_arr.size();
|
|
std::string entryStr = "";
|
|
|
|
for (size_t i = 0; i < arrayItemCnt; i++)
|
|
{
|
|
auto& child = limbTransformations_arr[i];
|
|
child.DeclareReferences(varPrefix);
|
|
entryStr += StringHelper::Sprintf("\t{ %s },", child.GetBodySourceCode().c_str());
|
|
|
|
if (i < arrayItemCnt - 1)
|
|
entryStr += "\n";
|
|
}
|
|
|
|
uint32_t unk_C_Offset = Seg2Filespace(limbTransformations, parent->baseAddress);
|
|
Declaration* decl = parent->GetDeclaration(unk_C_Offset);
|
|
if (decl == nullptr)
|
|
{
|
|
parent->AddDeclarationArray(unk_C_Offset, res.GetDeclarationAlignment(),
|
|
arrayItemCnt * res.GetRawDataSize(),
|
|
res.GetSourceTypeName(), unk_C_Str, arrayItemCnt, entryStr);
|
|
}
|
|
else
|
|
decl->declBody = entryStr;
|
|
}
|
|
}
|
|
|
|
std::string SkinLimbModif::GetBodySourceCode() const
|
|
{
|
|
std::string skinVertices_Str;
|
|
std::string 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",
|
|
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 SkinLimbModif::GetSourceTypeName() const
|
|
{
|
|
return "SkinLimbModif";
|
|
}
|
|
|
|
ZResourceType SkinLimbModif::GetResourceType() const
|
|
{
|
|
// TODO
|
|
return ZResourceType::Error;
|
|
}
|
|
|
|
size_t SkinLimbModif::GetRawDataSize() const
|
|
{
|
|
return 0x10;
|
|
}
|
|
|
|
/* SkinAnimatedLimbData */
|
|
|
|
SkinAnimatedLimbData::SkinAnimatedLimbData(ZFile* nParent) : ZResource(nParent)
|
|
{
|
|
}
|
|
|
|
void SkinAnimatedLimbData::ParseRawData()
|
|
{
|
|
const auto& rawData = parent->GetRawData();
|
|
|
|
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 (limbModifications != 0 && GETSEGNUM(limbModifications) == parent->segment)
|
|
{
|
|
uint32_t limbModifications_Offset = Seg2Filespace(limbModifications, parent->baseAddress);
|
|
|
|
limbModifications_arr.reserve(limbModifCount);
|
|
for (size_t i = 0; i < limbModifCount; i++)
|
|
{
|
|
SkinLimbModif limbModifications_data(parent);
|
|
limbModifications_data.ExtractFromFile(limbModifications_Offset);
|
|
limbModifications_arr.push_back(limbModifications_data);
|
|
|
|
limbModifications_Offset += limbModifications_data.GetRawDataSize();
|
|
}
|
|
}
|
|
}
|
|
|
|
void SkinAnimatedLimbData::DeclareReferences(const std::string& prefix)
|
|
{
|
|
std::string varPrefix = prefix;
|
|
if (name != "")
|
|
varPrefix = name;
|
|
|
|
ZResource::DeclareReferences(varPrefix);
|
|
|
|
if (limbModifications != SEGMENTED_NULL && GETSEGNUM(limbModifications) == parent->segment)
|
|
{
|
|
const auto& res = limbModifications_arr.at(0);
|
|
std::string limbModifications_Str = res.GetDefaultName(varPrefix);
|
|
|
|
size_t arrayItemCnt = limbModifications_arr.size();
|
|
std::string entryStr = "";
|
|
|
|
for (size_t i = 0; i < arrayItemCnt; i++)
|
|
{
|
|
auto& child = limbModifications_arr[i];
|
|
child.DeclareReferences(varPrefix);
|
|
entryStr += StringHelper::Sprintf("\t{ %s },", child.GetBodySourceCode().c_str());
|
|
|
|
if (i < arrayItemCnt - 1)
|
|
entryStr += "\n";
|
|
}
|
|
|
|
uint32_t limbModifications_Offset = Seg2Filespace(limbModifications, parent->baseAddress);
|
|
Declaration* decl = parent->GetDeclaration(limbModifications_Offset);
|
|
if (decl == nullptr)
|
|
{
|
|
parent->AddDeclarationArray(limbModifications_Offset, res.GetDeclarationAlignment(),
|
|
arrayItemCnt * res.GetRawDataSize(),
|
|
res.GetSourceTypeName(), limbModifications_Str,
|
|
arrayItemCnt, entryStr);
|
|
}
|
|
else
|
|
decl->declBody = entryStr;
|
|
}
|
|
|
|
if (dlist != SEGMENTED_NULL && GETSEGNUM(dlist) == parent->segment)
|
|
{
|
|
uint32_t dlist_Offset = Seg2Filespace(dlist, parent->baseAddress);
|
|
|
|
int32_t dlistLength = ZDisplayList::GetDListLength(
|
|
parent->GetRawData(), dlist_Offset,
|
|
Globals::Instance->game == ZGame::OOT_SW97 ? DListType::F3DEX : DListType::F3DZEX);
|
|
ZDisplayList* dlist_data = new ZDisplayList(parent);
|
|
dlist_data->ExtractFromBinary(dlist_Offset, dlistLength);
|
|
|
|
std::string dListStr =
|
|
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 SkinAnimatedLimbData::GetBodySourceCode() const
|
|
{
|
|
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", totalVtxCount,
|
|
limbModifications_Str.c_str());
|
|
entryStr +=
|
|
StringHelper::Sprintf("\t%s, %s\n", limbModifications_Str.c_str(), dlist_Str.c_str());
|
|
|
|
return entryStr;
|
|
}
|
|
|
|
std::string SkinAnimatedLimbData::GetSourceTypeName() const
|
|
{
|
|
return "SkinAnimatedLimbData";
|
|
}
|
|
|
|
ZResourceType SkinAnimatedLimbData::GetResourceType() const
|
|
{
|
|
// TODO
|
|
return ZResourceType::Error;
|
|
}
|
|
|
|
size_t SkinAnimatedLimbData::GetRawDataSize() const
|
|
{
|
|
return 0x0C;
|
|
}
|