mirror of
https://github.com/zeldaret/oot.git
synced 2025-08-10 17:00:19 +00:00
5c147e5e03
* copy over the xml * Rename anims * A bunch of renames * minor extract_assets fixes * git subrepo pull --force tools/ZAPD subrepo: subdir: "tools/ZAPD" merged: "820678b4e" upstream: origin: "https://github.com/zeldaret/ZAPD.git" branch: "master" commit: "820678b4e" git-subrepo: version: "0.4.3" origin: "???" commit: "???" * Change rgb5a1 to rgba16 * eye and eyebrows * some dlists * git subrepo pull --force tools/ZAPD subrepo: subdir: "tools/ZAPD" merged: "6be9af65d" upstream: origin: "https://github.com/zeldaret/ZAPD.git" branch: "master" commit: "6be9af65d" git-subrepo: version: "0.4.3" origin: "???" commit: "???"
788 lines
22 KiB
C++
788 lines
22 KiB
C++
#include "ZLimb.h"
|
|
#include <cassert>
|
|
#include "BitConverter.h"
|
|
#include "Globals.h"
|
|
#include "StringHelper.h"
|
|
|
|
REGISTER_ZFILENODE(Limb, ZLimb);
|
|
|
|
Struct_800A57C0::Struct_800A57C0(const std::vector<uint8_t>& rawData, uint32_t fileOffset)
|
|
{
|
|
unk_0 = BitConverter::ToUInt16BE(rawData, fileOffset + 0x00);
|
|
unk_2 = BitConverter::ToInt16BE(rawData, fileOffset + 0x02);
|
|
unk_4 = BitConverter::ToInt16BE(rawData, fileOffset + 0x04);
|
|
unk_6 = BitConverter::ToInt8BE(rawData, fileOffset + 0x06);
|
|
unk_7 = BitConverter::ToInt8BE(rawData, fileOffset + 0x07);
|
|
unk_8 = BitConverter::ToInt8BE(rawData, fileOffset + 0x08);
|
|
unk_9 = BitConverter::ToUInt8BE(rawData, fileOffset + 0x09);
|
|
}
|
|
Struct_800A57C0::Struct_800A57C0(const std::vector<uint8_t>& rawData, uint32_t fileOffset,
|
|
size_t index)
|
|
: Struct_800A57C0(rawData, fileOffset + index * GetRawDataSize())
|
|
{
|
|
}
|
|
|
|
std::string Struct_800A57C0::GetSourceOutputCode() 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);
|
|
}
|
|
|
|
size_t Struct_800A57C0::GetRawDataSize()
|
|
{
|
|
return 0x0A;
|
|
}
|
|
|
|
std::string Struct_800A57C0::GetSourceTypeName()
|
|
{
|
|
return "Struct_800A57C0";
|
|
}
|
|
|
|
Struct_800A598C_2::Struct_800A598C_2(const std::vector<uint8_t>& rawData, uint32_t fileOffset)
|
|
{
|
|
unk_0 = BitConverter::ToUInt8BE(rawData, fileOffset + 0x00);
|
|
x = BitConverter::ToInt16BE(rawData, fileOffset + 0x02);
|
|
y = BitConverter::ToInt16BE(rawData, fileOffset + 0x04);
|
|
z = BitConverter::ToInt16BE(rawData, fileOffset + 0x06);
|
|
unk_8 = BitConverter::ToUInt8BE(rawData, fileOffset + 0x08);
|
|
}
|
|
Struct_800A598C_2::Struct_800A598C_2(const std::vector<uint8_t>& rawData, uint32_t fileOffset,
|
|
size_t index)
|
|
: Struct_800A598C_2(rawData, fileOffset + index * GetRawDataSize())
|
|
{
|
|
}
|
|
|
|
std::string Struct_800A598C_2::GetSourceOutputCode() const
|
|
{
|
|
return StringHelper::Sprintf("0x%02X, %i, %i, %i, 0x%02X", unk_0, x, y, z, unk_8);
|
|
}
|
|
|
|
size_t Struct_800A598C_2::GetRawDataSize()
|
|
{
|
|
return 0x0A;
|
|
}
|
|
|
|
std::string Struct_800A598C_2::GetSourceTypeName()
|
|
{
|
|
return "Struct_800A598C_2";
|
|
}
|
|
|
|
Struct_800A598C::Struct_800A598C(ZFile* parent, const std::vector<uint8_t>& rawData,
|
|
uint32_t fileOffset)
|
|
: parent(parent)
|
|
{
|
|
unk_0 = BitConverter::ToUInt16BE(rawData, fileOffset + 0x00);
|
|
unk_2 = BitConverter::ToUInt16BE(rawData, fileOffset + 0x02);
|
|
unk_4 = BitConverter::ToUInt16BE(rawData, fileOffset + 0x04);
|
|
unk_8 = BitConverter::ToUInt32BE(rawData, fileOffset + 0x08);
|
|
unk_C = BitConverter::ToUInt32BE(rawData, fileOffset + 0x0C);
|
|
|
|
if (unk_8 != 0)
|
|
{
|
|
uint32_t unk_8_Offset = Seg2Filespace(unk_8, parent->baseAddress);
|
|
for (size_t i = 0; i < unk_0; i++)
|
|
{
|
|
unk_8_arr.emplace_back(rawData, unk_8_Offset, i);
|
|
}
|
|
}
|
|
|
|
if (unk_C != 0)
|
|
{
|
|
uint32_t unk_C_Offset = Seg2Filespace(unk_C, parent->baseAddress);
|
|
for (size_t i = 0; i < unk_2; i++)
|
|
{
|
|
unk_C_arr.emplace_back(rawData, unk_C_Offset, i);
|
|
}
|
|
}
|
|
}
|
|
Struct_800A598C::Struct_800A598C(ZFile* parent, const std::vector<uint8_t>& rawData,
|
|
uint32_t fileOffset, size_t index)
|
|
: Struct_800A598C(parent, rawData, fileOffset + index * GetRawDataSize())
|
|
{
|
|
}
|
|
|
|
void Struct_800A598C::PreGenSourceFiles(const std::string& prefix)
|
|
{
|
|
std::string entryStr;
|
|
|
|
if (unk_8 != 0)
|
|
{
|
|
uint32_t unk_8_Offset = Seg2Filespace(unk_8, parent->baseAddress);
|
|
std::string unk_8_Str =
|
|
StringHelper::Sprintf("%sSkinLimb_%s_%06X", prefix.c_str(),
|
|
Struct_800A57C0::GetSourceTypeName().c_str(), unk_8_Offset);
|
|
|
|
size_t arrayItemCnt = unk_8_arr.size();
|
|
entryStr = "";
|
|
size_t i = 0;
|
|
|
|
for (auto& child : unk_8_arr)
|
|
{
|
|
entryStr += StringHelper::Sprintf(" { %s },%s", child.GetSourceOutputCode().c_str(),
|
|
(++i < arrayItemCnt) ? "\n" : "");
|
|
}
|
|
|
|
Declaration* decl = parent->GetDeclaration(unk_8_Offset);
|
|
|
|
if (decl == nullptr)
|
|
{
|
|
parent->AddDeclarationArray(unk_8_Offset, DeclarationAlignment::None,
|
|
arrayItemCnt * Struct_800A57C0::GetRawDataSize(),
|
|
Struct_800A57C0::GetSourceTypeName(), unk_8_Str,
|
|
arrayItemCnt, entryStr);
|
|
}
|
|
else
|
|
{
|
|
decl->text = entryStr;
|
|
}
|
|
}
|
|
|
|
if (unk_C != 0)
|
|
{
|
|
uint32_t unk_C_Offset = Seg2Filespace(unk_C, parent->baseAddress);
|
|
std::string unk_C_Str =
|
|
StringHelper::Sprintf("%sSkinLimb_%s_%06X", prefix.c_str(),
|
|
Struct_800A598C_2::GetSourceTypeName().c_str(), unk_C_Offset);
|
|
|
|
size_t arrayItemCnt = unk_C_arr.size();
|
|
entryStr = "";
|
|
size_t i = 0;
|
|
|
|
for (auto& child : unk_C_arr)
|
|
{
|
|
entryStr += StringHelper::Sprintf(" { %s },%s", child.GetSourceOutputCode().c_str(),
|
|
(++i < arrayItemCnt) ? "\n" : "");
|
|
}
|
|
|
|
Declaration* decl = parent->GetDeclaration(unk_C_Offset);
|
|
if (decl == nullptr)
|
|
{
|
|
parent->AddDeclarationArray(unk_C_Offset, DeclarationAlignment::None,
|
|
arrayItemCnt * Struct_800A598C_2::GetRawDataSize(),
|
|
Struct_800A598C_2::GetSourceTypeName(), unk_C_Str,
|
|
arrayItemCnt, entryStr);
|
|
}
|
|
else
|
|
{
|
|
decl->text = entryStr;
|
|
}
|
|
}
|
|
}
|
|
|
|
std::string Struct_800A598C::GetSourceOutputCode(const std::string& prefix) const
|
|
{
|
|
std::string entryStr;
|
|
|
|
std::string unk_8_Str = "NULL";
|
|
|
|
if (unk_8 != 0)
|
|
{
|
|
uint32_t unk_8_Offset = Seg2Filespace(unk_8, parent->baseAddress);
|
|
unk_8_Str =
|
|
StringHelper::Sprintf("%sSkinLimb_%s_%06X", prefix.c_str(),
|
|
Struct_800A57C0::GetSourceTypeName().c_str(), unk_8_Offset);
|
|
}
|
|
|
|
std::string unk_C_Str = "NULL";
|
|
|
|
if (unk_C != 0)
|
|
{
|
|
uint32_t unk_C_Offset = Seg2Filespace(unk_C, parent->baseAddress);
|
|
unk_C_Str =
|
|
StringHelper::Sprintf("%sSkinLimb_%s_%06X", prefix.c_str(),
|
|
Struct_800A598C_2::GetSourceTypeName().c_str(), unk_C_Offset);
|
|
}
|
|
|
|
entryStr = StringHelper::Sprintf("\n ARRAY_COUNTU(%s), ARRAY_COUNTU(%s),\n",
|
|
unk_8_Str.c_str(), unk_C_Str.c_str());
|
|
entryStr += StringHelper::Sprintf(" %i, %s, %s\n ", unk_4, unk_8_Str.c_str(),
|
|
unk_C_Str.c_str());
|
|
entryStr = StringHelper::Sprintf("\n ARRAY_COUNTU(%s), ARRAY_COUNTU(%s),\n",
|
|
unk_8_Str.c_str(), unk_C_Str.c_str());
|
|
entryStr += StringHelper::Sprintf(" %i, %s, %s\n ", unk_4, unk_8_Str.c_str(),
|
|
unk_C_Str.c_str());
|
|
|
|
return entryStr;
|
|
}
|
|
|
|
size_t Struct_800A598C::GetRawDataSize()
|
|
{
|
|
return 0x10;
|
|
}
|
|
|
|
std::string Struct_800A598C::GetSourceTypeName()
|
|
{
|
|
return "Struct_800A598C";
|
|
}
|
|
|
|
Struct_800A5E28::Struct_800A5E28(ZFile* parent, const std::vector<uint8_t>& nRawData,
|
|
uint32_t fileOffset)
|
|
: parent(parent)
|
|
{
|
|
unk_0 = BitConverter::ToUInt16BE(nRawData, fileOffset + 0x00);
|
|
unk_2 = BitConverter::ToUInt16BE(nRawData, fileOffset + 0x02);
|
|
unk_4 = BitConverter::ToUInt32BE(nRawData, fileOffset + 0x04);
|
|
unk_8 = BitConverter::ToUInt32BE(nRawData, fileOffset + 0x08);
|
|
|
|
if (unk_4 != 0)
|
|
{
|
|
uint32_t unk_4_Offset = Seg2Filespace(unk_4, parent->baseAddress);
|
|
|
|
for (size_t i = 0; i < unk_2; i++)
|
|
{
|
|
unk_4_arr.emplace_back(parent, nRawData, unk_4_Offset, i);
|
|
}
|
|
}
|
|
}
|
|
|
|
Struct_800A5E28::~Struct_800A5E28()
|
|
{
|
|
delete unk_8_dlist;
|
|
}
|
|
|
|
void Struct_800A5E28::PreGenSourceFiles(const std::string& prefix)
|
|
{
|
|
if (unk_4 != 0)
|
|
{
|
|
uint32_t unk_4_Offset = Seg2Filespace(unk_4, parent->baseAddress);
|
|
std::string unk_4_Str =
|
|
StringHelper::Sprintf("%sSkinLimb_%s_%06X", prefix.c_str(),
|
|
Struct_800A598C::GetSourceTypeName().c_str(), unk_4_Offset);
|
|
|
|
std::string entryStr = "";
|
|
uint16_t arrayItemCnt = unk_4_arr.size();
|
|
|
|
size_t i = 0;
|
|
|
|
for (auto& child : unk_4_arr)
|
|
{
|
|
child.PreGenSourceFiles(prefix);
|
|
entryStr +=
|
|
StringHelper::Sprintf(" { %s },%s", child.GetSourceOutputCode(prefix).c_str(),
|
|
(++i < arrayItemCnt) ? "\n" : "");
|
|
}
|
|
|
|
Declaration* decl = parent->GetDeclaration(unk_4_Offset);
|
|
|
|
if (decl == nullptr)
|
|
{
|
|
parent->AddDeclarationArray(unk_4_Offset, DeclarationAlignment::None,
|
|
arrayItemCnt * Struct_800A598C::GetRawDataSize(),
|
|
Struct_800A598C::GetSourceTypeName(), unk_4_Str,
|
|
arrayItemCnt, entryStr);
|
|
}
|
|
else
|
|
{
|
|
decl->text = entryStr;
|
|
}
|
|
}
|
|
|
|
if (unk_8 != 0)
|
|
{
|
|
uint32_t unk_8_Offset = Seg2Filespace(unk_8, parent->baseAddress);
|
|
|
|
int32_t dlistLength = ZDisplayList::GetDListLength(
|
|
parent->GetRawData(), unk_8_Offset,
|
|
Globals::Instance->game == ZGame::OOT_SW97 ? DListType::F3DEX : DListType::F3DZEX);
|
|
unk_8_dlist = new ZDisplayList(unk_8_Offset, dlistLength, parent);
|
|
|
|
std::string dListStr =
|
|
StringHelper::Sprintf("%sSkinLimbDL_%06X", prefix.c_str(), unk_8_Offset);
|
|
unk_8_dlist->SetName(dListStr);
|
|
unk_8_dlist->GetSourceOutputCode(prefix);
|
|
}
|
|
}
|
|
|
|
std::string Struct_800A5E28::GetSourceOutputCode(const std::string& prefix) const
|
|
{
|
|
std::string entryStr = "";
|
|
|
|
std::string unk_4_Str = "NULL";
|
|
|
|
if (unk_4 != 0)
|
|
{
|
|
uint32_t unk_4_Offset = Seg2Filespace(unk_4, parent->baseAddress);
|
|
Declaration* decl = parent->GetDeclaration(unk_4_Offset);
|
|
|
|
if (decl == nullptr)
|
|
{
|
|
unk_4_Str =
|
|
StringHelper::Sprintf("%sSkinLimb_%s_%06X", prefix.c_str(),
|
|
Struct_800A598C::GetSourceTypeName().c_str(), unk_4_Offset);
|
|
}
|
|
else
|
|
{
|
|
unk_4_Str = decl->varName;
|
|
}
|
|
}
|
|
|
|
std::string unk_8_Str = "NULL";
|
|
if (unk_8 != 0)
|
|
{
|
|
uint32_t unk_8_Offset = Seg2Filespace(unk_8, parent->baseAddress);
|
|
Declaration* decl = parent->GetDeclaration(unk_8_Offset);
|
|
if (decl == nullptr)
|
|
{
|
|
// Something went wrong...
|
|
unk_8_Str = StringHelper::Sprintf("0x%08X", unk_8);
|
|
}
|
|
else
|
|
{
|
|
unk_8_Str = decl->varName;
|
|
}
|
|
}
|
|
|
|
return StringHelper::Sprintf("\n %i, ARRAY_COUNTU(%s),\n %s, %s\n", unk_0,
|
|
unk_4_Str.c_str(), unk_4_Str.c_str(), unk_8_Str.c_str());
|
|
}
|
|
|
|
size_t Struct_800A5E28::GetRawDataSize()
|
|
{
|
|
return 0x0C;
|
|
}
|
|
|
|
std::string Struct_800A5E28::GetSourceTypeName()
|
|
{
|
|
return "Struct_800A5E28";
|
|
}
|
|
|
|
ZLimb::ZLimb(ZFile* nParent) : ZResource(nParent)
|
|
{
|
|
dListPtr = 0;
|
|
dList2Ptr = 0;
|
|
RegisterOptionalAttribute("LimbType");
|
|
RegisterOptionalAttribute("Type");
|
|
}
|
|
|
|
ZLimb::ZLimb(ZLimbType limbType, const std::string& prefix, uint32_t nRawDataIndex, ZFile* nParent)
|
|
: ZLimb(nParent)
|
|
{
|
|
rawDataIndex = nRawDataIndex;
|
|
parent = nParent;
|
|
type = limbType;
|
|
|
|
name = StringHelper::Sprintf("%sLimb_%06X", prefix.c_str(), GetFileAddress());
|
|
|
|
ParseRawData();
|
|
}
|
|
|
|
void ZLimb::ExtractFromXML(tinyxml2::XMLElement* reader, uint32_t nRawDataIndex)
|
|
{
|
|
ZResource::ExtractFromXML(reader, nRawDataIndex);
|
|
|
|
parent->AddDeclaration(GetFileAddress(), DeclarationAlignment::None, GetRawDataSize(),
|
|
GetSourceTypeName(), name, "");
|
|
}
|
|
|
|
void ZLimb::ParseXML(tinyxml2::XMLElement* reader)
|
|
{
|
|
ZResource::ParseXML(reader);
|
|
|
|
// Reading from a <Skeleton/>
|
|
std::string limbType = registeredAttributes.at("LimbType").value;
|
|
if (limbType == "") // Reading from a <Limb/>
|
|
limbType = registeredAttributes.at("Type").value;
|
|
|
|
if (limbType == "")
|
|
{
|
|
fprintf(stderr,
|
|
"ZLimb::ParseXML: Warning in '%s'.\n"
|
|
"\t Missing 'LimbType' attribute in xml.\n"
|
|
"\t Defaulting to 'Standard'.\n",
|
|
name.c_str());
|
|
type = ZLimbType::Standard;
|
|
}
|
|
else
|
|
{
|
|
type = GetTypeByAttributeName(limbType);
|
|
if (type == ZLimbType::Invalid)
|
|
{
|
|
fprintf(stderr,
|
|
"ZLimb::ParseXML: Warning in '%s'.\n"
|
|
"\t Invalid LimbType found: '%s'.\n"
|
|
"\t Defaulting to 'Standard'.\n",
|
|
name.c_str(), limbType.c_str());
|
|
type = ZLimbType::Standard;
|
|
}
|
|
}
|
|
}
|
|
|
|
void ZLimb::ParseRawData()
|
|
{
|
|
ZResource::ParseRawData();
|
|
|
|
const auto& rawData = parent->GetRawData();
|
|
if (type == ZLimbType::Curve)
|
|
{
|
|
childIndex = rawData.at(rawDataIndex + 0);
|
|
siblingIndex = rawData.at(rawDataIndex + 1);
|
|
|
|
dListPtr = BitConverter::ToUInt32BE(rawData, rawDataIndex + 4);
|
|
dList2Ptr = BitConverter::ToUInt32BE(rawData, rawDataIndex + 8);
|
|
return;
|
|
}
|
|
if (type == ZLimbType::Legacy)
|
|
{
|
|
dListPtr = BitConverter::ToUInt32BE(rawData, rawDataIndex + 0x00);
|
|
legTransX = BitConverter::ToFloatBE(rawData, rawDataIndex + 0x04);
|
|
legTransY = BitConverter::ToFloatBE(rawData, rawDataIndex + 0x08);
|
|
legTransZ = BitConverter::ToFloatBE(rawData, rawDataIndex + 0x0C);
|
|
rotX = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0x10);
|
|
rotY = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0x12);
|
|
rotZ = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0x14);
|
|
childPtr = BitConverter::ToUInt32BE(rawData, rawDataIndex + 0x18);
|
|
siblingPtr = BitConverter::ToUInt32BE(rawData, rawDataIndex + 0x1C);
|
|
return;
|
|
}
|
|
|
|
transX = BitConverter::ToInt16BE(rawData, rawDataIndex + 0);
|
|
transY = BitConverter::ToInt16BE(rawData, rawDataIndex + 2);
|
|
transZ = BitConverter::ToInt16BE(rawData, rawDataIndex + 4);
|
|
|
|
childIndex = rawData.at(rawDataIndex + 6);
|
|
siblingIndex = rawData.at(rawDataIndex + 7);
|
|
|
|
switch (type)
|
|
{
|
|
case ZLimbType::LOD:
|
|
dList2Ptr = BitConverter::ToUInt32BE(rawData, rawDataIndex + 12);
|
|
// Intended fallthrough
|
|
case ZLimbType::Standard:
|
|
dListPtr = BitConverter::ToUInt32BE(rawData, rawDataIndex + 8);
|
|
break;
|
|
|
|
case ZLimbType::Skin:
|
|
skinSegmentType =
|
|
static_cast<ZLimbSkinType>(BitConverter::ToInt32BE(rawData, rawDataIndex + 8));
|
|
skinSegment = BitConverter::ToUInt32BE(rawData, rawDataIndex + 12);
|
|
if (skinSegmentType == ZLimbSkinType::SkinType_4 && skinSegment != 0)
|
|
{
|
|
uint32_t skinSegmentOffset = Seg2Filespace(skinSegment, parent->baseAddress);
|
|
segmentStruct = Struct_800A5E28(parent, rawData, skinSegmentOffset);
|
|
}
|
|
break;
|
|
default:
|
|
throw std::runtime_error("Invalid ZLimb type");
|
|
break;
|
|
}
|
|
}
|
|
|
|
void ZLimb::DeclareReferences(const std::string& prefix)
|
|
{
|
|
ZResource::DeclareReferences(prefix);
|
|
|
|
switch (type)
|
|
{
|
|
case ZLimbType::Legacy:
|
|
if (childPtr != 0 && GETSEGNUM(childPtr) == parent->segment)
|
|
{
|
|
uint32_t childOffset = Seg2Filespace(childPtr, parent->baseAddress);
|
|
if (!parent->HasDeclaration(childOffset))
|
|
{
|
|
ZLimb* child = new ZLimb(ZLimbType::Legacy, prefix, childOffset, parent);
|
|
child->GetSourceOutputCode(prefix);
|
|
parent->AddResource(child);
|
|
}
|
|
}
|
|
if (siblingPtr != 0 && GETSEGNUM(siblingPtr) == parent->segment)
|
|
{
|
|
uint32_t siblingdOffset = Seg2Filespace(siblingPtr, parent->baseAddress);
|
|
if (!parent->HasDeclaration(siblingdOffset))
|
|
{
|
|
ZLimb* sibling = new ZLimb(ZLimbType::Legacy, prefix, siblingdOffset, parent);
|
|
sibling->GetSourceOutputCode(prefix);
|
|
parent->AddResource(sibling);
|
|
}
|
|
}
|
|
break;
|
|
|
|
// TODO
|
|
case ZLimbType::Standard:
|
|
case ZLimbType::LOD:
|
|
case ZLimbType::Skin:
|
|
case ZLimbType::Curve:
|
|
break;
|
|
|
|
case ZLimbType::Invalid:
|
|
break;
|
|
}
|
|
}
|
|
|
|
size_t ZLimb::GetRawDataSize() const
|
|
{
|
|
switch (type)
|
|
{
|
|
case ZLimbType::Standard:
|
|
case ZLimbType::Curve:
|
|
return 0x0C;
|
|
|
|
case ZLimbType::LOD:
|
|
case ZLimbType::Skin:
|
|
return 0x10;
|
|
|
|
case ZLimbType::Legacy:
|
|
return 0x20;
|
|
|
|
case ZLimbType::Invalid:
|
|
break;
|
|
}
|
|
|
|
return 0x0C;
|
|
}
|
|
|
|
std::string ZLimb::GetSourceOutputCode(const std::string& prefix)
|
|
{
|
|
std::string limbPrefix = type == ZLimbType::Curve ? "Curve" : "";
|
|
std::string dListStr = GetLimbDListSourceOutputCode(prefix, limbPrefix, dListPtr);
|
|
limbPrefix = type == ZLimbType::Curve ? "Curve" : "Far";
|
|
std::string dListStr2 = GetLimbDListSourceOutputCode(prefix, limbPrefix, dList2Ptr);
|
|
|
|
std::string entryStr = "\n\t";
|
|
if (type == ZLimbType::Legacy)
|
|
{
|
|
std::string childName = parent->GetDeclarationPtrName(childPtr);
|
|
std::string siblingName = parent->GetDeclarationPtrName(siblingPtr);
|
|
|
|
entryStr += StringHelper::Sprintf("%s,\n", dListStr.c_str());
|
|
entryStr +=
|
|
StringHelper::Sprintf("\t{ %ff, %ff, %ff },\n", legTransX, legTransY, legTransZ);
|
|
entryStr += StringHelper::Sprintf("\t{ 0x%04X, 0x%04X, 0x%04X },\n", rotX, rotY, rotZ);
|
|
entryStr += StringHelper::Sprintf("\t%s,\n", childName.c_str());
|
|
entryStr += StringHelper::Sprintf("\t%s\n", siblingName.c_str());
|
|
}
|
|
else
|
|
{
|
|
if (type != ZLimbType::Curve)
|
|
{
|
|
entryStr += StringHelper::Sprintf("{ %i, %i, %i }, ", transX, transY, transZ);
|
|
}
|
|
|
|
entryStr += StringHelper::Sprintf("0x%02X, 0x%02X,\n", childIndex, siblingIndex);
|
|
|
|
switch (type)
|
|
{
|
|
case ZLimbType::Standard:
|
|
entryStr += StringHelper::Sprintf(" %s\n", dListStr.c_str());
|
|
break;
|
|
|
|
case ZLimbType::LOD:
|
|
case ZLimbType::Curve:
|
|
entryStr +=
|
|
StringHelper::Sprintf(" { %s, %s }\n", dListStr.c_str(), dListStr2.c_str());
|
|
break;
|
|
|
|
case ZLimbType::Skin:
|
|
entryStr += GetSourceOutputCodeSkin(prefix);
|
|
break;
|
|
|
|
case ZLimbType::Legacy:
|
|
break;
|
|
|
|
case ZLimbType::Invalid:
|
|
break;
|
|
}
|
|
}
|
|
|
|
Declaration* decl = parent->GetDeclaration(GetFileAddress());
|
|
|
|
if (decl == nullptr)
|
|
parent->AddDeclaration(GetFileAddress(), DeclarationAlignment::None, GetRawDataSize(),
|
|
GetSourceTypeName(), name, entryStr);
|
|
else
|
|
decl->text = entryStr;
|
|
|
|
return "";
|
|
}
|
|
|
|
std::string ZLimb::GetSourceTypeName() const
|
|
{
|
|
return GetSourceTypeName(type);
|
|
}
|
|
|
|
ZResourceType ZLimb::GetResourceType() const
|
|
{
|
|
return ZResourceType::Limb;
|
|
}
|
|
|
|
ZLimbType ZLimb::GetLimbType()
|
|
{
|
|
return type;
|
|
}
|
|
|
|
void ZLimb::SetLimbType(ZLimbType value)
|
|
{
|
|
type = value;
|
|
}
|
|
|
|
const char* ZLimb::GetSourceTypeName(ZLimbType limbType)
|
|
{
|
|
switch (limbType)
|
|
{
|
|
case ZLimbType::Standard:
|
|
return "StandardLimb";
|
|
|
|
case ZLimbType::LOD:
|
|
return "LodLimb";
|
|
|
|
case ZLimbType::Skin:
|
|
return "SkinLimb";
|
|
|
|
case ZLimbType::Curve:
|
|
return "SkelCurveLimb";
|
|
|
|
case ZLimbType::Legacy:
|
|
return "LegacyLimb";
|
|
|
|
default:
|
|
return "StandardLimb";
|
|
}
|
|
}
|
|
|
|
ZLimbType ZLimb::GetTypeByAttributeName(const std::string& attrName)
|
|
{
|
|
if (attrName == "Standard")
|
|
{
|
|
return ZLimbType::Standard;
|
|
}
|
|
if (attrName == "LOD")
|
|
{
|
|
return ZLimbType::LOD;
|
|
}
|
|
if (attrName == "Skin")
|
|
{
|
|
return ZLimbType::Skin;
|
|
}
|
|
if (attrName == "Curve")
|
|
{
|
|
return ZLimbType::Curve;
|
|
}
|
|
if (attrName == "Legacy")
|
|
{
|
|
return ZLimbType::Legacy;
|
|
}
|
|
return ZLimbType::Invalid;
|
|
}
|
|
|
|
uint32_t ZLimb::GetFileAddress()
|
|
{
|
|
return Seg2Filespace(rawDataIndex, parent->baseAddress);
|
|
}
|
|
|
|
// Returns the ptrname of a dlist. Declares it if it has not been declared yet.
|
|
std::string ZLimb::GetLimbDListSourceOutputCode(const std::string& prefix,
|
|
const std::string& limbPrefix, segptr_t dListPtr)
|
|
{
|
|
if (dListPtr == 0)
|
|
return "NULL";
|
|
|
|
uint32_t dListOffset = Seg2Filespace(dListPtr, parent->baseAddress);
|
|
|
|
// Check if pointing past the object's size
|
|
if (dListOffset > parent->GetRawData().size())
|
|
return StringHelper::Sprintf("0x%08X", dListPtr);
|
|
|
|
// Check if it is already declared
|
|
Declaration* decl = parent->GetDeclaration(dListOffset);
|
|
if (decl != nullptr)
|
|
return decl->varName;
|
|
|
|
// Check if it points to the middle of a DList
|
|
decl = parent->GetDeclarationRanged(dListOffset);
|
|
if (decl != nullptr)
|
|
{
|
|
// TODO: Figure out a way to not hardcode the "Gfx" type.
|
|
if (decl->varType == "Gfx")
|
|
{
|
|
uint32_t declAddress = parent->GetDeclarationRangedAddress(dListOffset);
|
|
if (dListOffset < declAddress + decl->size)
|
|
{
|
|
uint32_t index = (dListOffset - declAddress) / 8;
|
|
return StringHelper::Sprintf("&%s[%u]", decl->varName.c_str(), index);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Create the DList
|
|
std::string dListStr =
|
|
StringHelper::Sprintf("%s%sLimbDL_%06X", prefix.c_str(), limbPrefix.c_str(), dListOffset);
|
|
|
|
int32_t dlistLength = ZDisplayList::GetDListLength(
|
|
parent->GetRawData(), dListOffset,
|
|
Globals::Instance->game == ZGame::OOT_SW97 ? DListType::F3DEX : DListType::F3DZEX);
|
|
auto dList = new ZDisplayList(dListOffset, dlistLength, parent);
|
|
dList->SetName(dListStr);
|
|
dList->GetSourceOutputCode(prefix);
|
|
return dListStr;
|
|
}
|
|
|
|
std::string ZLimb::GetSourceOutputCodeSkin_Type_4(const std::string& prefix)
|
|
{
|
|
assert(type == ZLimbType::Skin);
|
|
assert(skinSegmentType == ZLimbSkinType::SkinType_4);
|
|
|
|
if (skinSegment == 0)
|
|
return "NULL";
|
|
|
|
uint32_t skinSegmentOffset = Seg2Filespace(skinSegment, parent->baseAddress);
|
|
|
|
std::string struct_800A5E28_Str;
|
|
Declaration* decl = parent->GetDeclaration(skinSegmentOffset);
|
|
if (decl == nullptr)
|
|
{
|
|
struct_800A5E28_Str =
|
|
StringHelper::Sprintf("%sSkinLimb_%s_%06X", prefix.c_str(),
|
|
Struct_800A5E28::GetSourceTypeName().c_str(), skinSegmentOffset);
|
|
|
|
segmentStruct.PreGenSourceFiles(prefix);
|
|
std::string entryStr = segmentStruct.GetSourceOutputCode(prefix);
|
|
|
|
parent->AddDeclaration(skinSegmentOffset, DeclarationAlignment::None,
|
|
Struct_800A5E28::GetRawDataSize(),
|
|
Struct_800A5E28::GetSourceTypeName(), struct_800A5E28_Str, entryStr);
|
|
}
|
|
else
|
|
{
|
|
struct_800A5E28_Str = decl->varName;
|
|
}
|
|
|
|
return struct_800A5E28_Str;
|
|
}
|
|
|
|
std::string ZLimb::GetSourceOutputCodeSkin(const std::string& prefix)
|
|
{
|
|
assert(type == ZLimbType::Skin);
|
|
|
|
std::string skinSegmentStr = "NULL";
|
|
|
|
if (skinSegment != 0)
|
|
{
|
|
switch (skinSegmentType)
|
|
{
|
|
case ZLimbSkinType::SkinType_4:
|
|
skinSegmentStr = "&" + GetSourceOutputCodeSkin_Type_4(prefix);
|
|
break;
|
|
case ZLimbSkinType::SkinType_DList:
|
|
skinSegmentStr = GetLimbDListSourceOutputCode(prefix, "Skin", skinSegment);
|
|
break;
|
|
default:
|
|
fprintf(stderr,
|
|
"ZLimb::GetSourceOutputCodeSkinType: Error in '%s'.\n\t Unknown segment type "
|
|
"for SkinLimb: '%i'. \n\tPlease report this.\n",
|
|
name.c_str(), static_cast<int32_t>(skinSegmentType));
|
|
break;
|
|
case ZLimbSkinType::SkinType_0:
|
|
case ZLimbSkinType::SkinType_5:
|
|
fprintf(stderr,
|
|
"ZLimb::GetSourceOutputCodeSkinType: Error in '%s'.\n\t Segment type for "
|
|
"SkinLimb not implemented: '%i'.\n",
|
|
name.c_str(), static_cast<int32_t>(skinSegmentType));
|
|
skinSegmentStr = StringHelper::Sprintf("0x%08X", skinSegment);
|
|
break;
|
|
}
|
|
}
|
|
|
|
std::string entryStr =
|
|
StringHelper::Sprintf(" 0x%02X, %s\n", skinSegmentType, skinSegmentStr.c_str());
|
|
|
|
return entryStr;
|
|
}
|