falso
/
mm
mirror of https://github.com/zeldaret/mm.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

ZAPD hotfix (#629) 

* git subrepo pull tools/ZAPD

subrepo:
  subdir:   "tools/ZAPD"
  merged:   "be71e26d9"
upstream:
  origin:   "https://github.com/zeldaret/ZAPD.git"
  branch:   "master"
  commit:   "be71e26d9"
git-subrepo:
  version:  "0.4.3"
  origin:   "https://github.com/ingydotnet/git-subrepo.git"
  commit:   "2f68596"

* git subrepo pull tools/ZAPD

subrepo:
  subdir:   "tools/ZAPD"
  merged:   "119a6883e"
upstream:
  origin:   "https://github.com/zeldaret/ZAPD.git"
  branch:   "master"
  commit:   "119a6883e"
git-subrepo:
  version:  "0.4.3"
  origin:   "https://github.com/ingydotnet/git-subrepo.git"
  commit:   "2f68596"
This commit is contained in:
Anghelo Carvajal 2022-01-21 01:40:12 -03:00 committed by GitHub
parent 1531f5b56f
commit 2a913635a4
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
16 changed files with 548 additions and 344 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
tools/ZAPD/.gitrepo
View File

@ -6,7 +6,7 @@
[subrepo] [subrepo]
remote = https://github.com/zeldaret/ZAPD.git remote = https://github.com/zeldaret/ZAPD.git
branch = master branch = master
commit = 0ba78130478ee1272bc0e2f2fec2d162e7f7f995 commit = 119a6883e6f795815744b9afd6a79084c619ddb6
parent = aa90d1ee2be577fb8a18c1c3c6dcafda2e732190 parent = 66a66f61b6368af0ed711803c54a963494329217
method = merge method = merge
cmdver = 0.4.3 cmdver = 0.4.3

12
tools/ZAPD/ZAPD/WarningHandler.cpp
View File

@ -199,8 +199,16 @@ bool WarningHandler::WasElevatedToError(WarningType warnType) {
* Print file/line/function info for debugging * Print file/line/function info for debugging
*/ */
void WarningHandler::FunctionPreamble(const char* filename, int32_t line, const char* function) { void WarningHandler::FunctionPreamble(const char* filename, int32_t line, const char* function) {
if (Globals::Instance->verbosity >= VerbosityLevel::VERBOSITY_DEBUG) { bool forcePrint = false;
fprintf(stderr, "%s:%i: in function %s:\n", filename, line, function);
#ifdef DEVELOPMENT
forcePrint = true;
#endif
fprintf(stderr, "\n");
if (forcePrint || Globals::Instance->verbosity >= VerbosityLevel::VERBOSITY_DEBUG) {
fprintf(stderr, "%s:%i: in function <%s>:\n", filename, line, function);
} }
} }

2
tools/ZAPD/ZAPD/ZAnimation.cpp
View File

@ -51,7 +51,7 @@ void ZNormalAnimation::ParseRawData()
{ {
ZAnimation::ParseRawData(); ZAnimation::ParseRawData();
const uint8_t* data = parent->GetRawData().data(); auto& data = parent->GetRawData();
rotationValuesSeg = BitConverter::ToInt32BE(data, rawDataIndex + 4); rotationValuesSeg = BitConverter::ToInt32BE(data, rawDataIndex + 4);
rotationIndicesSeg = BitConverter::ToInt32BE(data, rawDataIndex + 8); rotationIndicesSeg = BitConverter::ToInt32BE(data, rawDataIndex + 8);

34
tools/ZAPD/ZAPD/ZCollision.cpp
View File

@ -256,32 +256,28 @@ size_t ZCollisionHeader::GetRawDataSize() const
PolygonEntry::PolygonEntry(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex) PolygonEntry::PolygonEntry(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex)
{ {
const uint8_t* data = rawData.data(); type = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0);
vtxA = BitConverter::ToUInt16BE(rawData, rawDataIndex + 2);
type = BitConverter::ToUInt16BE(data, rawDataIndex + 0); vtxB = BitConverter::ToUInt16BE(rawData, rawDataIndex + 4);
vtxA = BitConverter::ToUInt16BE(data, rawDataIndex + 2); vtxC = BitConverter::ToUInt16BE(rawData, rawDataIndex + 6);
vtxB = BitConverter::ToUInt16BE(data, rawDataIndex + 4); a = BitConverter::ToUInt16BE(rawData, rawDataIndex + 8);
vtxC = BitConverter::ToUInt16BE(data, rawDataIndex + 6); b = BitConverter::ToUInt16BE(rawData, rawDataIndex + 10);
a = BitConverter::ToUInt16BE(data, rawDataIndex + 8); c = BitConverter::ToUInt16BE(rawData, rawDataIndex + 12);
b = BitConverter::ToUInt16BE(data, rawDataIndex + 10); d = BitConverter::ToUInt16BE(rawData, rawDataIndex + 14);
c = BitConverter::ToUInt16BE(data, rawDataIndex + 12);
d = BitConverter::ToUInt16BE(data, rawDataIndex + 14);
} }
WaterBoxHeader::WaterBoxHeader(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex) WaterBoxHeader::WaterBoxHeader(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex)
{ {
const uint8_t* data = rawData.data(); xMin = BitConverter::ToInt16BE(rawData, rawDataIndex + 0);
ySurface = BitConverter::ToInt16BE(rawData, rawDataIndex + 2);
xMin = BitConverter::ToInt16BE(data, rawDataIndex + 0); zMin = BitConverter::ToInt16BE(rawData, rawDataIndex + 4);
ySurface = BitConverter::ToInt16BE(data, rawDataIndex + 2); xLength = BitConverter::ToInt16BE(rawData, rawDataIndex + 6);
zMin = BitConverter::ToInt16BE(data, rawDataIndex + 4); zLength = BitConverter::ToInt16BE(rawData, rawDataIndex + 8);
xLength = BitConverter::ToInt16BE(data, rawDataIndex + 6);
zLength = BitConverter::ToInt16BE(data, rawDataIndex + 8);
if (Globals::Instance->game == ZGame::OOT_SW97) if (Globals::Instance->game == ZGame::OOT_SW97)
properties = BitConverter::ToInt16BE(data, rawDataIndex + 10); properties = BitConverter::ToInt16BE(rawData, rawDataIndex + 10);
else else
properties = BitConverter::ToInt32BE(data, rawDataIndex + 12); properties = BitConverter::ToInt32BE(rawData, rawDataIndex + 12);
} }
std::string WaterBoxHeader::GetBodySourceCode() const std::string WaterBoxHeader::GetBodySourceCode() const

186
tools/ZAPD/ZAPD/ZCutscene.cpp
View File

@ -445,30 +445,26 @@ size_t CutsceneCommand::GetCommandSize()
CutsceneCameraPoint::CutsceneCameraPoint(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex) CutsceneCameraPoint::CutsceneCameraPoint(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex)
{ {
const uint8_t* data = rawData.data(); continueFlag = rawData.at(rawDataIndex + 0);
cameraRoll = rawData.at(rawDataIndex + 1);
nextPointFrame = BitConverter::ToInt16BE(rawData, rawDataIndex + 2);
viewAngle = BitConverter::ToFloatBE(rawData, rawDataIndex + 4);
continueFlag = data[rawDataIndex + 0]; posX = BitConverter::ToInt16BE(rawData, rawDataIndex + 8);
cameraRoll = data[rawDataIndex + 1]; posY = BitConverter::ToInt16BE(rawData, rawDataIndex + 10);
nextPointFrame = BitConverter::ToInt16BE(data, rawDataIndex + 2); posZ = BitConverter::ToInt16BE(rawData, rawDataIndex + 12);
viewAngle = BitConverter::ToFloatBE(data, rawDataIndex + 4);
posX = BitConverter::ToInt16BE(data, rawDataIndex + 8); unused = BitConverter::ToInt16BE(rawData, rawDataIndex + 14);
posY = BitConverter::ToInt16BE(data, rawDataIndex + 10);
posZ = BitConverter::ToInt16BE(data, rawDataIndex + 12);
unused = BitConverter::ToInt16BE(data, rawDataIndex + 14);
} }
CutsceneCommandSetCameraPos::CutsceneCommandSetCameraPos(const std::vector<uint8_t>& rawData, CutsceneCommandSetCameraPos::CutsceneCommandSetCameraPos(const std::vector<uint8_t>& rawData,
uint32_t rawDataIndex) uint32_t rawDataIndex)
: CutsceneCommand(rawData, rawDataIndex) : CutsceneCommand(rawData, rawDataIndex)
{ {
const uint8_t* data = rawData.data(); base = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0);
startFrame = BitConverter::ToUInt16BE(rawData, rawDataIndex + 2);
base = BitConverter::ToUInt16BE(data, rawDataIndex + 0); endFrame = BitConverter::ToUInt16BE(rawData, rawDataIndex + 4);
startFrame = BitConverter::ToUInt16BE(data, rawDataIndex + 2); unused = BitConverter::ToUInt16BE(rawData, rawDataIndex + 6);
endFrame = BitConverter::ToUInt16BE(data, rawDataIndex + 4);
unused = BitConverter::ToUInt16BE(data, rawDataIndex + 6);
entries = std::vector<CutsceneCameraPoint*>(); entries = std::vector<CutsceneCameraPoint*>();
@ -711,17 +707,17 @@ size_t CutsceneCommandStopBGM::GetCommandSize()
EnvLightingEntry::EnvLightingEntry(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex) EnvLightingEntry::EnvLightingEntry(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex)
{ {
setting = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 0); setting = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0);
startFrame = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 2); startFrame = BitConverter::ToUInt16BE(rawData, rawDataIndex + 2);
endFrame = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 4); endFrame = BitConverter::ToUInt16BE(rawData, rawDataIndex + 4);
unused0 = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 6); unused0 = BitConverter::ToUInt16BE(rawData, rawDataIndex + 6);
unused1 = (uint32_t)BitConverter::ToInt32BE(rawData, rawDataIndex + 8); unused1 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 8);
unused2 = (uint32_t)BitConverter::ToInt32BE(rawData, rawDataIndex + 12); unused2 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 12);
unused3 = (uint32_t)BitConverter::ToInt32BE(rawData, rawDataIndex + 16); unused3 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 16);
unused4 = (uint32_t)BitConverter::ToInt32BE(rawData, rawDataIndex + 20); unused4 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 20);
unused5 = (uint32_t)BitConverter::ToInt32BE(rawData, rawDataIndex + 24); unused5 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 24);
unused6 = (uint32_t)BitConverter::ToInt32BE(rawData, rawDataIndex + 28); unused6 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 28);
unused7 = (uint32_t)BitConverter::ToInt32BE(rawData, rawDataIndex + 32); unused7 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 32);
} }
CutsceneCommandEnvLighting::CutsceneCommandEnvLighting(const std::vector<uint8_t>& rawData, CutsceneCommandEnvLighting::CutsceneCommandEnvLighting(const std::vector<uint8_t>& rawData,
@ -769,9 +765,9 @@ size_t CutsceneCommandEnvLighting::GetCommandSize()
Unknown9Entry::Unknown9Entry(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex) Unknown9Entry::Unknown9Entry(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex)
{ {
base = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 0); base = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0);
startFrame = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 2); startFrame = BitConverter::ToUInt16BE(rawData, rawDataIndex + 2);
endFrame = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 4); endFrame = BitConverter::ToUInt16BE(rawData, rawDataIndex + 4);
unk2 = rawData[rawDataIndex + 6]; unk2 = rawData[rawDataIndex + 6];
unk3 = rawData[rawDataIndex + 7]; unk3 = rawData[rawDataIndex + 7];
unk4 = rawData[rawDataIndex + 8]; unk4 = rawData[rawDataIndex + 8];
@ -824,18 +820,18 @@ size_t CutsceneCommandUnknown9::GetCommandSize()
UnkEntry::UnkEntry(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex) UnkEntry::UnkEntry(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex)
{ {
unused0 = (uint32_t)BitConverter::ToInt32BE(rawData, rawDataIndex + 0); unused0 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 0);
unused1 = (uint32_t)BitConverter::ToInt32BE(rawData, rawDataIndex + 4); unused1 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 4);
unused2 = (uint32_t)BitConverter::ToInt32BE(rawData, rawDataIndex + 8); unused2 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 8);
unused3 = (uint32_t)BitConverter::ToInt32BE(rawData, rawDataIndex + 12); unused3 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 12);
unused4 = (uint32_t)BitConverter::ToInt32BE(rawData, rawDataIndex + 16); unused4 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 16);
unused5 = (uint32_t)BitConverter::ToInt32BE(rawData, rawDataIndex + 20); unused5 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 20);
unused6 = (uint32_t)BitConverter::ToInt32BE(rawData, rawDataIndex + 24); unused6 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 24);
unused7 = (uint32_t)BitConverter::ToInt32BE(rawData, rawDataIndex + 28); unused7 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 28);
unused8 = (uint32_t)BitConverter::ToInt32BE(rawData, rawDataIndex + 32); unused8 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 32);
unused9 = (uint32_t)BitConverter::ToInt32BE(rawData, rawDataIndex + 36); unused9 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 36);
unused10 = (uint32_t)BitConverter::ToInt32BE(rawData, rawDataIndex + 40); unused10 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 40);
unused11 = (uint32_t)BitConverter::ToInt32BE(rawData, rawDataIndex + 44); unused11 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 44);
} }
CutsceneCommandUnknown::CutsceneCommandUnknown(const std::vector<uint8_t>& rawData, CutsceneCommandUnknown::CutsceneCommandUnknown(const std::vector<uint8_t>& rawData,
@ -883,9 +879,9 @@ size_t CutsceneCommandUnknown::GetCommandSize()
DayTimeEntry::DayTimeEntry(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex) DayTimeEntry::DayTimeEntry(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex)
{ {
base = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 0); base = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0);
startFrame = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 2); startFrame = BitConverter::ToUInt16BE(rawData, rawDataIndex + 2);
endFrame = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 4); endFrame = BitConverter::ToUInt16BE(rawData, rawDataIndex + 4);
hour = rawData[rawDataIndex + 6]; hour = rawData[rawDataIndex + 6];
minute = rawData[rawDataIndex + 7]; minute = rawData[rawDataIndex + 7];
unused = rawData[rawDataIndex + 8]; unused = rawData[rawDataIndex + 8];
@ -934,12 +930,12 @@ size_t CutsceneCommandDayTime::GetCommandSize()
TextboxEntry::TextboxEntry(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex) TextboxEntry::TextboxEntry(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex)
{ {
base = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 0); base = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0);
startFrame = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 2); startFrame = BitConverter::ToUInt16BE(rawData, rawDataIndex + 2);
endFrame = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 4); endFrame = BitConverter::ToUInt16BE(rawData, rawDataIndex + 4);
type = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 6); type = BitConverter::ToUInt16BE(rawData, rawDataIndex + 6);
textID1 = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 8); textID1 = BitConverter::ToUInt16BE(rawData, rawDataIndex + 8);
textID2 = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 10); textID2 = BitConverter::ToUInt16BE(rawData, rawDataIndex + 10);
} }
CutsceneCommandTextbox::CutsceneCommandTextbox(const std::vector<uint8_t>& rawData, CutsceneCommandTextbox::CutsceneCommandTextbox(const std::vector<uint8_t>& rawData,
@ -994,23 +990,21 @@ size_t CutsceneCommandTextbox::GetCommandSize()
ActorAction::ActorAction(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex) ActorAction::ActorAction(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex)
{ {
const uint8_t* data = rawData.data(); action = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0);
startFrame = BitConverter::ToUInt16BE(rawData, rawDataIndex + 2);
action = (uint16_t)BitConverter::ToInt16BE(data, rawDataIndex + 0); endFrame = BitConverter::ToUInt16BE(rawData, rawDataIndex + 4);
startFrame = (uint16_t)BitConverter::ToInt16BE(data, rawDataIndex + 2); rotX = BitConverter::ToUInt16BE(rawData, rawDataIndex + 6);
endFrame = (uint16_t)BitConverter::ToInt16BE(data, rawDataIndex + 4); rotY = BitConverter::ToUInt16BE(rawData, rawDataIndex + 8);
rotX = (uint16_t)BitConverter::ToInt16BE(data, rawDataIndex + 6); rotZ = BitConverter::ToUInt16BE(rawData, rawDataIndex + 10);
rotY = (uint16_t)BitConverter::ToInt16BE(data, rawDataIndex + 8); startPosX = BitConverter::ToInt32BE(rawData, rawDataIndex + 12);
rotZ = (uint16_t)BitConverter::ToInt16BE(data, rawDataIndex + 10); startPosY = BitConverter::ToInt32BE(rawData, rawDataIndex + 16);
startPosX = BitConverter::ToInt32BE(data, rawDataIndex + 12); startPosZ = BitConverter::ToInt32BE(rawData, rawDataIndex + 20);
startPosY = BitConverter::ToInt32BE(data, rawDataIndex + 16); endPosX = BitConverter::ToInt32BE(rawData, rawDataIndex + 24);
startPosZ = BitConverter::ToInt32BE(data, rawDataIndex + 20); endPosY = BitConverter::ToInt32BE(rawData, rawDataIndex + 28);
endPosX = BitConverter::ToInt32BE(data, rawDataIndex + 24); endPosZ = BitConverter::ToInt32BE(rawData, rawDataIndex + 32);
endPosY = BitConverter::ToInt32BE(data, rawDataIndex + 28); normalX = BitConverter::ToFloatBE(rawData, rawDataIndex + 36);
endPosZ = BitConverter::ToInt32BE(data, rawDataIndex + 32); normalY = BitConverter::ToFloatBE(rawData, rawDataIndex + 40);
normalX = BitConverter::ToFloatBE(data, rawDataIndex + 36); normalZ = BitConverter::ToFloatBE(rawData, rawDataIndex + 44);
normalY = BitConverter::ToFloatBE(data, rawDataIndex + 40);
normalZ = BitConverter::ToFloatBE(data, rawDataIndex + 44);
} }
CutsceneCommandActorAction::CutsceneCommandActorAction(const std::vector<uint8_t>& rawData, CutsceneCommandActorAction::CutsceneCommandActorAction(const std::vector<uint8_t>& rawData,
@ -1074,10 +1068,10 @@ CutsceneCommandTerminator::CutsceneCommandTerminator(const std::vector<uint8_t>&
{ {
rawDataIndex += 4; rawDataIndex += 4;
base = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 0); base = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0);
startFrame = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 2); startFrame = BitConverter::ToUInt16BE(rawData, rawDataIndex + 2);
endFrame = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 4); endFrame = BitConverter::ToUInt16BE(rawData, rawDataIndex + 4);
unknown = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 6); // endFrame duplicate unknown = BitConverter::ToUInt16BE(rawData, rawDataIndex + 6); // endFrame duplicate
} }
std::string CutsceneCommandTerminator::GetCName() std::string CutsceneCommandTerminator::GetCName()
@ -1102,9 +1096,9 @@ size_t CutsceneCommandTerminator::GetCommandSize()
CutsceneCommandEnd::CutsceneCommandEnd(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex) CutsceneCommandEnd::CutsceneCommandEnd(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex)
: CutsceneCommand(rawData, rawDataIndex) : CutsceneCommand(rawData, rawDataIndex)
{ {
base = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 0); base = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0);
startFrame = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 2); startFrame = BitConverter::ToUInt16BE(rawData, rawDataIndex + 2);
endFrame = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 4); endFrame = BitConverter::ToUInt16BE(rawData, rawDataIndex + 4);
} }
std::string CutsceneCommandEnd::GenerateSourceCode([[maybe_unused]] uint32_t baseAddress) std::string CutsceneCommandEnd::GenerateSourceCode([[maybe_unused]] uint32_t baseAddress)
@ -1128,22 +1122,20 @@ size_t CutsceneCommandEnd::GetCommandSize()
SpecialActionEntry::SpecialActionEntry(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex) SpecialActionEntry::SpecialActionEntry(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex)
{ {
const uint8_t* data = rawData.data(); base = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0);
startFrame = BitConverter::ToUInt16BE(rawData, rawDataIndex + 2);
base = BitConverter::ToUInt16BE(data, rawDataIndex + 0); endFrame = BitConverter::ToUInt16BE(rawData, rawDataIndex + 4);
startFrame = BitConverter::ToUInt16BE(data, rawDataIndex + 2); unused0 = BitConverter::ToUInt16BE(rawData, rawDataIndex + 6);
endFrame = BitConverter::ToUInt16BE(data, rawDataIndex + 4); unused1 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 8);
unused0 = BitConverter::ToUInt16BE(data, rawDataIndex + 6); unused2 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 12);
unused1 = BitConverter::ToUInt32BE(data, rawDataIndex + 8); unused3 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 16);
unused2 = BitConverter::ToUInt32BE(data, rawDataIndex + 12); unused4 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 20);
unused3 = BitConverter::ToUInt32BE(data, rawDataIndex + 16); unused5 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 24);
unused4 = BitConverter::ToUInt32BE(data, rawDataIndex + 20); unused6 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 28);
unused5 = BitConverter::ToUInt32BE(data, rawDataIndex + 24); unused7 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 32);
unused6 = BitConverter::ToUInt32BE(data, rawDataIndex + 28); unused8 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 36);
unused7 = BitConverter::ToUInt32BE(data, rawDataIndex + 32); unused9 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 40);
unused8 = BitConverter::ToUInt32BE(data, rawDataIndex + 36); unused10 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 44);
unused9 = BitConverter::ToUInt32BE(data, rawDataIndex + 40);
unused10 = BitConverter::ToUInt32BE(data, rawDataIndex + 44);
} }
CutsceneCommandSpecialAction::CutsceneCommandSpecialAction(const std::vector<uint8_t>& rawData, CutsceneCommandSpecialAction::CutsceneCommandSpecialAction(const std::vector<uint8_t>& rawData,
@ -1194,9 +1186,9 @@ size_t CutsceneCommandSpecialAction::GetCommandSize()
CutsceneCommandNop::CutsceneCommandNop(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex) CutsceneCommandNop::CutsceneCommandNop(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex)
: CutsceneCommand(rawData, rawDataIndex) : CutsceneCommand(rawData, rawDataIndex)
{ {
base = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 0); base = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0);
startFrame = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 2); startFrame = BitConverter::ToUInt16BE(rawData, rawDataIndex + 2);
endFrame = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 4); endFrame = BitConverter::ToUInt16BE(rawData, rawDataIndex + 4);
} }
std::string CutsceneCommandNop::GetCName() std::string CutsceneCommandNop::GetCName()
@ -1215,9 +1207,9 @@ CutsceneCommandSceneTransFX::CutsceneCommandSceneTransFX(const std::vector<uint8
{ {
rawDataIndex += 4; rawDataIndex += 4;
base = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 0); base = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0);
startFrame = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 2); startFrame = BitConverter::ToUInt16BE(rawData, rawDataIndex + 2);
endFrame = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 4); endFrame = BitConverter::ToUInt16BE(rawData, rawDataIndex + 4);
} }
std::string CutsceneCommandSceneTransFX::GenerateSourceCode([[maybe_unused]] uint32_t baseAddress) std::string CutsceneCommandSceneTransFX::GenerateSourceCode([[maybe_unused]] uint32_t baseAddress)

9
tools/ZAPD/ZAPD/ZFile.cpp
View File

@ -406,7 +406,7 @@ void ZFile::AddResource(ZResource* res)
resources.push_back(res); resources.push_back(res);
} }
ZResource* ZFile::FindResource(uint32_t rawDataIndex) ZResource* ZFile::FindResource(offset_t rawDataIndex)
{ {
for (ZResource* res : resources) for (ZResource* res : resources)
{ {
@ -776,6 +776,11 @@ void ZFile::GenerateSourceHeaderFiles()
{ {
OutputFormatter formatter; OutputFormatter formatter;
std::string objectNameUpper = StringHelper::ToUpper(GetName());
formatter.Write(StringHelper::Sprintf("#ifndef %s_H\n#define %s_H 1\n\n",
objectNameUpper.c_str(), objectNameUpper.c_str()));
for (ZResource* res : resources) for (ZResource* res : resources)
{ {
std::string resSrc = res->GetSourceOutputHeader(""); std::string resSrc = res->GetSourceOutputHeader("");
@ -792,6 +797,8 @@ void ZFile::GenerateSourceHeaderFiles()
formatter.Write(ProcessExterns()); formatter.Write(ProcessExterns());
formatter.Write("#endif\n");
fs::path headerFilename = GetSourceOutputFolderPath() / outName.stem().concat(".h"); fs::path headerFilename = GetSourceOutputFolderPath() / outName.stem().concat(".h");
if (Globals::Instance->verbosity >= VerbosityLevel::VERBOSITY_INFO) if (Globals::Instance->verbosity >= VerbosityLevel::VERBOSITY_INFO)

2
tools/ZAPD/ZAPD/ZFile.h
View File

@ -52,7 +52,7 @@ public:
void ExtractResources(); void ExtractResources();
void BuildSourceFile(); void BuildSourceFile();
void AddResource(ZResource* res); void AddResource(ZResource* res);
ZResource* FindResource(uint32_t rawDataIndex); ZResource* FindResource(offset_t rawDataIndex);
std::vector<ZResource*> GetResourcesOfType(ZResourceType resType); std::vector<ZResource*> GetResourcesOfType(ZResourceType resType);
Declaration* AddDeclaration(offset_t address, DeclarationAlignment alignment, size_t size, Declaration* AddDeclaration(offset_t address, DeclarationAlignment alignment, size_t size,

29
tools/ZAPD/ZAPD/ZLimb.cpp
View File

@ -4,12 +4,15 @@
#include "Globals.h" #include "Globals.h"
#include "Utils/BitConverter.h" #include "Utils/BitConverter.h"
#include "Utils/StringHelper.h"
#include "WarningHandler.h" #include "WarningHandler.h"
#include "ZSkeleton.h"
REGISTER_ZFILENODE(Limb, ZLimb); REGISTER_ZFILENODE(Limb, ZLimb);
ZLimb::ZLimb(ZFile* nParent) : ZResource(nParent), segmentStruct(nParent) ZLimb::ZLimb(ZFile* nParent) : ZResource(nParent), segmentStruct(nParent)
{ {
RegisterOptionalAttribute("EnumName");
RegisterOptionalAttribute("LimbType"); RegisterOptionalAttribute("LimbType");
RegisterOptionalAttribute("Type"); RegisterOptionalAttribute("Type");
} }
@ -30,6 +33,12 @@ void ZLimb::ParseXML(tinyxml2::XMLElement* reader)
{ {
ZResource::ParseXML(reader); ZResource::ParseXML(reader);
auto& enumNameXml = registeredAttributes.at("EnumName").value;
if (enumNameXml != "")
{
enumName = enumNameXml;
}
// Reading from a <Skeleton/> // Reading from a <Skeleton/>
std::string limbType = registeredAttributes.at("LimbType").value; std::string limbType = registeredAttributes.at("LimbType").value;
if (limbType == "") // Reading from a <Limb/> if (limbType == "") // Reading from a <Limb/>
@ -240,11 +249,24 @@ std::string ZLimb::GetBodySourceCode() const
} }
else else
{ {
std::string childStr;
std::string siblingStr;
if (limbsTable != nullptr)
{
childStr = limbsTable->GetLimbEnumName(childIndex);
siblingStr = limbsTable->GetLimbEnumName(siblingIndex);
}
else
{
childStr = StringHelper::Sprintf("0x%02X", childIndex);
siblingStr = StringHelper::Sprintf("0x%02X", siblingIndex);
}
if (type != ZLimbType::Curve) if (type != ZLimbType::Curve)
{ {
entryStr += StringHelper::Sprintf("{ %i, %i, %i }, ", transX, transY, transZ); entryStr += StringHelper::Sprintf("{ %i, %i, %i }, ", transX, transY, transZ);
} }
entryStr += StringHelper::Sprintf("0x%02X, 0x%02X,\n", childIndex, siblingIndex); entryStr += StringHelper::Sprintf("%s, %s,\n", childStr.c_str(), siblingStr.c_str());
switch (type) switch (type)
{ {
@ -352,6 +374,11 @@ ZLimbType ZLimb::GetTypeByAttributeName(const std::string& attrName)
return ZLimbType::Invalid; return ZLimbType::Invalid;
} }
void ZLimb::SetLimbIndex(uint8_t nLimbIndex)
{
limbIndex = nLimbIndex;
}
void ZLimb::DeclareDList(segptr_t dListSegmentedPtr, const std::string& prefix, void ZLimb::DeclareDList(segptr_t dListSegmentedPtr, const std::string& prefix,
const std::string& limbSuffix) const std::string& limbSuffix)
{ {

9
tools/ZAPD/ZAPD/ZLimb.h
View File

@ -18,9 +18,14 @@ enum class ZLimbType
Legacy, Legacy,
}; };
class ZLimbTable;
class ZLimb : public ZResource class ZLimb : public ZResource
{ {
public: public:
std::string enumName;
ZLimbTable* limbsTable = nullptr; // borrowed pointer, do not delete!
ZLimbType type = ZLimbType::Standard; ZLimbType type = ZLimbType::Standard;
ZLimbSkinType skinSegmentType = ZLimbSkinType::SkinType_0; // Skin only ZLimbSkinType skinSegmentType = ZLimbSkinType::SkinType_0; // Skin only
@ -39,6 +44,8 @@ public:
int16_t transX, transY, transZ; int16_t transX, transY, transZ;
uint8_t childIndex, siblingIndex; uint8_t childIndex, siblingIndex;
uint8_t limbIndex = 0;
ZLimb(ZFile* nParent); ZLimb(ZFile* nParent);
void ExtractFromBinary(uint32_t nRawDataIndex, ZLimbType nType); void ExtractFromBinary(uint32_t nRawDataIndex, ZLimbType nType);
@ -59,6 +66,8 @@ public:
static const char* GetSourceTypeName(ZLimbType limbType); static const char* GetSourceTypeName(ZLimbType limbType);
static ZLimbType GetTypeByAttributeName(const std::string& attrName); static ZLimbType GetTypeByAttributeName(const std::string& attrName);
void SetLimbIndex(uint8_t nLimbIndex);
protected: protected:
void DeclareDList(segptr_t dListSegmentedPtr, const std::string& prefix, void DeclareDList(segptr_t dListSegmentedPtr, const std::string& prefix,
const std::string& limbSuffix); const std::string& limbSuffix);

215
tools/ZAPD/ZAPD/ZSkeleton.cpp
View File

@ -10,10 +10,13 @@
REGISTER_ZFILENODE(Skeleton, ZSkeleton); REGISTER_ZFILENODE(Skeleton, ZSkeleton);
REGISTER_ZFILENODE(LimbTable, ZLimbTable); REGISTER_ZFILENODE(LimbTable, ZLimbTable);
ZSkeleton::ZSkeleton(ZFile* nParent) : ZResource(nParent), limbsTable(nParent) ZSkeleton::ZSkeleton(ZFile* nParent) : ZResource(nParent)
{ {
RegisterRequiredAttribute("Type"); RegisterRequiredAttribute("Type");
RegisterRequiredAttribute("LimbType"); RegisterRequiredAttribute("LimbType");
RegisterOptionalAttribute("EnumName");
RegisterOptionalAttribute("LimbNone");
RegisterOptionalAttribute("LimbMax");
} }
void ZSkeleton::ParseXML(tinyxml2::XMLElement* reader) void ZSkeleton::ParseXML(tinyxml2::XMLElement* reader)
@ -42,6 +45,41 @@ void ZSkeleton::ParseXML(tinyxml2::XMLElement* reader)
limbTypeXml.c_str()), limbTypeXml.c_str()),
"Defaulting to 'Standard'."); "Defaulting to 'Standard'.");
} }
enumName = registeredAttributes.at("EnumName").value;
limbNoneName = registeredAttributes.at("LimbNone").value;
limbMaxName = registeredAttributes.at("LimbMax").value;
if (enumName != "")
{
if (limbNoneName == "" || limbMaxName == "")
{
HANDLE_ERROR_RESOURCE(WarningType::MissingAttribute, parent, this, rawDataIndex,
"'EnumName' attribute was used but either 'LimbNone' or "
"'LimbMax' attribute is missing",
"");
}
}
if (limbNoneName != "")
{
if (limbMaxName == "")
{
HANDLE_ERROR_RESOURCE(
WarningType::MissingAttribute, parent, this, rawDataIndex,
"'LimbNone' attribute was used but 'LimbMax' attribute is missing", "");
}
}
if (limbMaxName != "")
{
if (limbNoneName == "")
{
HANDLE_ERROR_RESOURCE(
WarningType::MissingAttribute, parent, this, rawDataIndex,
"'LimbMax' attribute was used but 'LimbNone' attribute is missing", "");
}
}
} }
void ZSkeleton::ParseRawData() void ZSkeleton::ParseRawData()
@ -56,12 +94,6 @@ void ZSkeleton::ParseRawData()
{ {
dListCount = BitConverter::ToUInt8BE(rawData, rawDataIndex + 8); dListCount = BitConverter::ToUInt8BE(rawData, rawDataIndex + 8);
} }
if (limbsArrayAddress != 0 && GETSEGNUM(limbsArrayAddress) == parent->segment)
{
uint32_t ptr = Seg2Filespace(limbsArrayAddress, parent->baseAddress);
limbsTable.ExtractFromBinary(ptr, limbType, limbCount);
}
} }
void ZSkeleton::DeclareReferences(const std::string& prefix) void ZSkeleton::DeclareReferences(const std::string& prefix)
@ -72,14 +104,33 @@ void ZSkeleton::DeclareReferences(const std::string& prefix)
ZResource::DeclareReferences(defaultPrefix); ZResource::DeclareReferences(defaultPrefix);
if (limbsArrayAddress != 0 && GETSEGNUM(limbsArrayAddress) == parent->segment) if (limbsArrayAddress != SEGMENTED_NULL && GETSEGNUM(limbsArrayAddress) == parent->segment)
{ {
uint32_t ptr = Seg2Filespace(limbsArrayAddress, parent->baseAddress); offset_t ptr = Seg2Filespace(limbsArrayAddress, parent->baseAddress);
if (!parent->HasDeclaration(ptr)) if (!parent->HasDeclaration(ptr))
{ {
limbsTable.SetName(StringHelper::Sprintf("%sLimbs", defaultPrefix.c_str())); limbsTable = new ZLimbTable(parent);
limbsTable.DeclareReferences(prefix); limbsTable->ExtractFromBinary(ptr, limbType, limbCount);
limbsTable.GetSourceOutputCode(prefix); limbsTable->SetName(StringHelper::Sprintf("%sLimbs", defaultPrefix.c_str()));
parent->AddResource(limbsTable);
}
else
{
limbsTable = static_cast<ZLimbTable*>(parent->FindResource(ptr));
}
if (limbsTable->enumName == "")
{
limbsTable->enumName = enumName;
}
if (limbsTable->limbNoneName == "")
{
limbsTable->limbNoneName = limbNoneName;
}
if (limbsTable->limbMaxName == "")
{
limbsTable->limbMaxName = limbMaxName;
} }
} }
} }
@ -89,14 +140,26 @@ std::string ZSkeleton::GetBodySourceCode() const
std::string limbArrayName; std::string limbArrayName;
Globals::Instance->GetSegmentedPtrName(limbsArrayAddress, parent, "", limbArrayName); Globals::Instance->GetSegmentedPtrName(limbsArrayAddress, parent, "", limbArrayName);
std::string countStr;
assert(limbsTable != nullptr);
// There are some Skeletons with the wrong limb count on them, so this check is necessary.
if (limbsTable->count == limbCount)
{
countStr = StringHelper::Sprintf("ARRAY_COUNT(%s)", limbArrayName.c_str());
}
else
{
countStr = StringHelper::Sprintf("%i", limbCount);
}
switch (type) switch (type)
{ {
case ZSkeletonType::Normal: case ZSkeletonType::Normal:
case ZSkeletonType::Curve: case ZSkeletonType::Curve:
return StringHelper::Sprintf("\n\t%s, %i\n", limbArrayName.c_str(), limbCount); return StringHelper::Sprintf("\n\t%s, %s\n", limbArrayName.c_str(), countStr.c_str());
case ZSkeletonType::Flex: case ZSkeletonType::Flex:
return StringHelper::Sprintf("\n\t{ %s, %i }, %i\n", limbArrayName.c_str(), limbCount, return StringHelper::Sprintf("\n\t{ %s, %s }, %i\n", limbArrayName.c_str(), countStr.c_str(),
dListCount); dListCount);
} }
@ -153,6 +216,9 @@ ZLimbTable::ZLimbTable(ZFile* nParent) : ZResource(nParent)
{ {
RegisterRequiredAttribute("LimbType"); RegisterRequiredAttribute("LimbType");
RegisterRequiredAttribute("Count"); RegisterRequiredAttribute("Count");
RegisterOptionalAttribute("EnumName");
RegisterOptionalAttribute("LimbNone");
RegisterOptionalAttribute("LimbMax");
} }
void ZLimbTable::ExtractFromBinary(uint32_t nRawDataIndex, ZLimbType nLimbType, size_t nCount) void ZLimbTable::ExtractFromBinary(uint32_t nRawDataIndex, ZLimbType nLimbType, size_t nCount)
@ -179,6 +245,40 @@ void ZLimbTable::ParseXML(tinyxml2::XMLElement* reader)
} }
count = StringHelper::StrToL(registeredAttributes.at("Count").value); count = StringHelper::StrToL(registeredAttributes.at("Count").value);
enumName = registeredAttributes.at("EnumName").value;
limbNoneName = registeredAttributes.at("LimbNone").value;
limbMaxName = registeredAttributes.at("LimbMax").value;
if (enumName != "")
{
if (limbNoneName == "" || limbMaxName == "")
{
HANDLE_ERROR_RESOURCE(
WarningType::MissingAttribute, parent, this, rawDataIndex,
"'EnumName' attribute was used but 'LimbNone'/'LimbMax' attributes is missing", "");
}
}
if (limbNoneName != "")
{
if (limbMaxName == "")
{
HANDLE_ERROR_RESOURCE(
WarningType::MissingAttribute, parent, this, rawDataIndex,
"'LimbNone' attribute was used but 'LimbMax' attribute is missing", "");
}
}
if (limbMaxName != "")
{
if (limbNoneName == "")
{
HANDLE_ERROR_RESOURCE(
WarningType::MissingAttribute, parent, this, rawDataIndex,
"'LimbMax' attribute was used but 'LimbNone' attribute is missing", "");
}
}
} }
void ZLimbTable::ParseRawData() void ZLimbTable::ParseRawData()
@ -209,15 +309,28 @@ void ZLimbTable::DeclareReferences(const std::string& prefix)
if (limbAddress != 0 && GETSEGNUM(limbAddress) == parent->segment) if (limbAddress != 0 && GETSEGNUM(limbAddress) == parent->segment)
{ {
uint32_t limbOffset = Seg2Filespace(limbAddress, parent->baseAddress); uint32_t limbOffset = Seg2Filespace(limbAddress, parent->baseAddress);
ZLimb* limb;
if (!parent->HasDeclaration(limbOffset)) if (!parent->HasDeclaration(limbOffset))
{ {
ZLimb* limb = new ZLimb(parent); limb = new ZLimb(parent);
limb->ExtractFromBinary(limbOffset, limbType); limb->ExtractFromBinary(limbOffset, limbType);
limb->SetName(limb->GetDefaultName(varPrefix)); limb->SetName(limb->GetDefaultName(varPrefix));
limb->DeclareVar(varPrefix, ""); limb->DeclareVar(varPrefix, "");
limb->DeclareReferences(varPrefix); limb->DeclareReferences(varPrefix);
parent->AddResource(limb); parent->AddResource(limb);
} }
else
{
limb = static_cast<ZLimb*>(parent->FindResource(limbOffset));
assert(limb != nullptr);
assert(limb->GetResourceType() == ZResourceType::Limb);
}
limb->limbsTable = this;
limb->SetLimbIndex(i + 1);
limbsReferences.push_back(limb);
} }
} }
} }
@ -246,6 +359,13 @@ std::string ZLimbTable::GetBodySourceCode() const
Globals::Instance->GetSegmentedPtrName(limbsAddresses[i], parent, "", limbName); Globals::Instance->GetSegmentedPtrName(limbsAddresses[i], parent, "", limbName);
body += StringHelper::Sprintf("\t%s,", limbName.c_str()); body += StringHelper::Sprintf("\t%s,", limbName.c_str());
auto& limb = limbsReferences.at(i);
std::string limbEnumName = limb->enumName;
if (limbEnumName != "")
{
body += StringHelper::Sprintf(" /* %s */", limbEnumName.c_str());
}
if (i + 1 < count) if (i + 1 < count)
body += "\n"; body += "\n";
} }
@ -253,6 +373,46 @@ std::string ZLimbTable::GetBodySourceCode() const
return body; return body;
} }
std::string ZLimbTable::GetSourceOutputHeader([[maybe_unused]] const std::string& prefix)
{
if (limbNoneName == "" || limbMaxName == "" || enumName == "")
{
// Don't produce a enum of any of those attributes is missing
return "";
}
std::string limbEnum = StringHelper::Sprintf("typedef enum %s {\n", enumName.c_str());
// This assumes there isn't any skeleton with more than 0x100 limbs
limbEnum += StringHelper::Sprintf(" /* 0x00 */ %s,\n", limbNoneName.c_str());
size_t i = 0;
for (; i < count; i++)
{
auto& limb = limbsReferences.at(i);
std::string limbEnumName = limb->enumName;
if (limbEnumName == "")
{
HANDLE_ERROR_RESOURCE(
WarningType::MissingAttribute, parent, this, rawDataIndex,
"Skeleton's enum attributes were used but at least one limb is missing its "
"'LimbName' attribute",
StringHelper::Sprintf("When processing limb %02i, named '%s' at offset '0x%X'",
i + 1, limb->GetName().c_str(), limb->GetRawDataIndex()));
}
limbEnum += StringHelper::Sprintf(" /* 0x%02X */ %s,\n", i + 1, limbEnumName.c_str());
}
limbEnum += StringHelper::Sprintf(" /* 0x%02X */ %s\n", i + 1, limbMaxName.c_str());
limbEnum += StringHelper::Sprintf("} %s;\n", enumName.c_str());
return limbEnum;
}
std::string ZLimbTable::GetSourceTypeName() const std::string ZLimbTable::GetSourceTypeName() const
{ {
switch (limbType) switch (limbType)
@ -283,3 +443,28 @@ size_t ZLimbTable::GetRawDataSize() const
{ {
return 4 * limbsAddresses.size(); return 4 * limbsAddresses.size();
} }
std::string ZLimbTable::GetLimbEnumName(uint8_t limbIndex) const
{
if (limbIndex == 0xFF)
{
return "LIMB_DONE";
}
if (limbIndex < count)
{
std::string limbEnumName = limbsReferences.at(limbIndex)->enumName;
if (limbEnumName != "")
{
return StringHelper::Sprintf("%s - 1", limbEnumName.c_str());
}
}
else
{
HANDLE_WARNING_RESOURCE(WarningType::InvalidExtractedData, parent, this, rawDataIndex,
StringHelper::Sprintf("Limb index '%02i' out of range", limbIndex),
"");
}
return StringHelper::Sprintf("0x%02X", limbIndex);
}

25
tools/ZAPD/ZAPD/ZSkeleton.h
View File

@ -18,6 +18,17 @@ enum class ZSkeletonType
class ZLimbTable : public ZResource class ZLimbTable : public ZResource
{ {
public: public:
ZLimbType limbType = ZLimbType::Standard;
size_t count = 0;
std::vector<segptr_t> limbsAddresses;
std::vector<ZLimb*> limbsReferences; // borrowed pointers, do not delete!
// XML attributes
std::string enumName;
std::string limbNoneName;
std::string limbMaxName;
ZLimbTable(ZFile* nParent); ZLimbTable(ZFile* nParent);
void ExtractFromBinary(uint32_t nRawDataIndex, ZLimbType nLimbType, size_t nCount); void ExtractFromBinary(uint32_t nRawDataIndex, ZLimbType nLimbType, size_t nCount);
@ -30,16 +41,14 @@ public:
std::string GetBodySourceCode() const override; std::string GetBodySourceCode() const override;
std::string GetSourceOutputHeader(const std::string& prefix) override;
std::string GetSourceTypeName() const override; std::string GetSourceTypeName() const override;
ZResourceType GetResourceType() const override; ZResourceType GetResourceType() const override;
size_t GetRawDataSize() const override; size_t GetRawDataSize() const override;
protected: std::string GetLimbEnumName(uint8_t limbIndex) const;
ZLimbType limbType = ZLimbType::Standard;
size_t count = 0;
std::vector<segptr_t> limbsAddresses;
}; };
class ZSkeleton : public ZResource class ZSkeleton : public ZResource
@ -47,6 +56,10 @@ class ZSkeleton : public ZResource
public: public:
ZSkeletonType type = ZSkeletonType::Normal; ZSkeletonType type = ZSkeletonType::Normal;
ZLimbType limbType = ZLimbType::Standard; ZLimbType limbType = ZLimbType::Standard;
std::string enumName;
std::string limbNoneName;
std::string limbMaxName;
segptr_t limbsArrayAddress; segptr_t limbsArrayAddress;
uint8_t limbCount = 0; uint8_t limbCount = 0;
uint8_t dListCount = 0; // FLEX SKELETON ONLY uint8_t dListCount = 0; // FLEX SKELETON ONLY
@ -68,5 +81,5 @@ public:
uint8_t GetLimbCount(); uint8_t GetLimbCount();
protected: protected:
ZLimbTable limbsTable; ZLimbTable* limbsTable = nullptr; // borrowed pointer, do not delete!
}; };

107
tools/ZAPD/ZAPD/ZTexture.cpp
View File

@ -350,34 +350,42 @@ void ZTexture::DeclareReferences([[maybe_unused]] const std::string& prefix)
void ZTexture::PrepareRawDataFromFile(const fs::path& pngFilePath) void ZTexture::PrepareRawDataFromFile(const fs::path& pngFilePath)
{ {
textureData.ReadPng(pngFilePath);
width = textureData.GetWidth();
height = textureData.GetHeight();
textureDataRaw.clear();
textureDataRaw.resize(ALIGN8(GetRawDataSize()));
switch (format) switch (format)
{ {
case TextureType::RGBA16bpp: case TextureType::RGBA16bpp:
PrepareRawDataRGBA16(pngFilePath); PrepareRawDataRGBA16();
break; break;
case TextureType::RGBA32bpp: case TextureType::RGBA32bpp:
PrepareRawDataRGBA32(pngFilePath); PrepareRawDataRGBA32();
break; break;
case TextureType::Grayscale4bpp: case TextureType::Grayscale4bpp:
PrepareRawDataGrayscale4(pngFilePath); PrepareRawDataGrayscale4();
break; break;
case TextureType::Grayscale8bpp: case TextureType::Grayscale8bpp:
PrepareRawDataGrayscale8(pngFilePath); PrepareRawDataGrayscale8();
break; break;
case TextureType::GrayscaleAlpha4bpp: case TextureType::GrayscaleAlpha4bpp:
PrepareRawDataGrayscaleAlpha4(pngFilePath); PrepareRawDataGrayscaleAlpha4();
break; break;
case TextureType::GrayscaleAlpha8bpp: case TextureType::GrayscaleAlpha8bpp:
PrepareRawDataGrayscaleAlpha8(pngFilePath); PrepareRawDataGrayscaleAlpha8();
break; break;
case TextureType::GrayscaleAlpha16bpp: case TextureType::GrayscaleAlpha16bpp:
PrepareRawDataGrayscaleAlpha16(pngFilePath); PrepareRawDataGrayscaleAlpha16();
break; break;
case TextureType::Palette4bpp: case TextureType::Palette4bpp:
PrepareRawDataPalette4(pngFilePath); PrepareRawDataPalette4();
break; break;
case TextureType::Palette8bpp: case TextureType::Palette8bpp:
PrepareRawDataPalette8(pngFilePath); PrepareRawDataPalette8();
break; break;
case TextureType::Error: case TextureType::Error:
HANDLE_ERROR_PROCESS(WarningType::InvalidPNG, "Input PNG file has invalid format type", ""); HANDLE_ERROR_PROCESS(WarningType::InvalidPNG, "Input PNG file has invalid format type", "");
@ -385,15 +393,8 @@ void ZTexture::PrepareRawDataFromFile(const fs::path& pngFilePath)
} }
} }
void ZTexture::PrepareRawDataRGBA16(const fs::path& rgbaPath) void ZTexture::PrepareRawDataRGBA16()
{ {
textureData.ReadPng(rgbaPath);
width = textureData.GetWidth();
height = textureData.GetHeight();
textureDataRaw.clear();
textureDataRaw.resize(GetRawDataSize());
for (uint16_t y = 0; y < height; y++) for (uint16_t y = 0; y < height; y++)
{ {
for (uint16_t x = 0; x < width; x++) for (uint16_t x = 0; x < width; x++)
@ -415,15 +416,8 @@ void ZTexture::PrepareRawDataRGBA16(const fs::path& rgbaPath)
} }
} }
void ZTexture::PrepareRawDataRGBA32(const fs::path& rgbaPath) void ZTexture::PrepareRawDataRGBA32()
{ {
textureData.ReadPng(rgbaPath);
width = textureData.GetWidth();
height = textureData.GetHeight();
textureDataRaw.clear();
textureDataRaw.resize(GetRawDataSize());
for (uint16_t y = 0; y < height; y++) for (uint16_t y = 0; y < height; y++)
{ {
for (uint16_t x = 0; x < width; x++) for (uint16_t x = 0; x < width; x++)
@ -439,15 +433,8 @@ void ZTexture::PrepareRawDataRGBA32(const fs::path& rgbaPath)
} }
} }
void ZTexture::PrepareRawDataGrayscale4(const fs::path& grayPath) void ZTexture::PrepareRawDataGrayscale4()
{ {
textureData.ReadPng(grayPath);
width = textureData.GetWidth();
height = textureData.GetHeight();
textureDataRaw.clear();
textureDataRaw.resize(GetRawDataSize());
for (uint16_t y = 0; y < height; y++) for (uint16_t y = 0; y < height; y++)
{ {
for (uint16_t x = 0; x < width; x += 2) for (uint16_t x = 0; x < width; x += 2)
@ -461,15 +448,8 @@ void ZTexture::PrepareRawDataGrayscale4(const fs::path& grayPath)
} }
} }
void ZTexture::PrepareRawDataGrayscale8(const fs::path& grayPath) void ZTexture::PrepareRawDataGrayscale8()
{ {
textureData.ReadPng(grayPath);
width = textureData.GetWidth();
height = textureData.GetHeight();
textureDataRaw.clear();
textureDataRaw.resize(GetRawDataSize());
for (uint16_t y = 0; y < height; y++) for (uint16_t y = 0; y < height; y++)
{ {
for (uint16_t x = 0; x < width; x++) for (uint16_t x = 0; x < width; x++)
@ -481,15 +461,8 @@ void ZTexture::PrepareRawDataGrayscale8(const fs::path& grayPath)
} }
} }
void ZTexture::PrepareRawDataGrayscaleAlpha4(const fs::path& grayAlphaPath) void ZTexture::PrepareRawDataGrayscaleAlpha4()
{ {
textureData.ReadPng(grayAlphaPath);
width = textureData.GetWidth();
height = textureData.GetHeight();
textureDataRaw.clear();
textureDataRaw.resize(GetRawDataSize());
for (uint16_t y = 0; y < height; y++) for (uint16_t y = 0; y < height; y++)
{ {
for (uint16_t x = 0; x < width; x += 2) for (uint16_t x = 0; x < width; x += 2)
@ -514,15 +487,8 @@ void ZTexture::PrepareRawDataGrayscaleAlpha4(const fs::path& grayAlphaPath)
} }
} }
void ZTexture::PrepareRawDataGrayscaleAlpha8(const fs::path& grayAlphaPath) void ZTexture::PrepareRawDataGrayscaleAlpha8()
{ {
textureData.ReadPng(grayAlphaPath);
width = textureData.GetWidth();
height = textureData.GetHeight();
textureDataRaw.clear();
textureDataRaw.resize(GetRawDataSize());
for (uint16_t y = 0; y < height; y++) for (uint16_t y = 0; y < height; y++)
{ {
for (uint16_t x = 0; x < width; x++) for (uint16_t x = 0; x < width; x++)
@ -538,15 +504,8 @@ void ZTexture::PrepareRawDataGrayscaleAlpha8(const fs::path& grayAlphaPath)
} }
} }
void ZTexture::PrepareRawDataGrayscaleAlpha16(const fs::path& grayAlphaPath) void ZTexture::PrepareRawDataGrayscaleAlpha16()
{ {
textureData.ReadPng(grayAlphaPath);
width = textureData.GetWidth();
height = textureData.GetHeight();
textureDataRaw.clear();
textureDataRaw.resize(GetRawDataSize());
for (uint16_t y = 0; y < height; y++) for (uint16_t y = 0; y < height; y++)
{ {
for (uint16_t x = 0; x < width; x++) for (uint16_t x = 0; x < width; x++)
@ -563,15 +522,8 @@ void ZTexture::PrepareRawDataGrayscaleAlpha16(const fs::path& grayAlphaPath)
} }
} }
void ZTexture::PrepareRawDataPalette4(const fs::path& palPath) void ZTexture::PrepareRawDataPalette4()
{ {
textureData.ReadPng(palPath);
width = textureData.GetWidth();
height = textureData.GetHeight();
textureDataRaw.clear();
textureDataRaw.resize(GetRawDataSize());
for (uint16_t y = 0; y < height; y++) for (uint16_t y = 0; y < height; y++)
{ {
for (uint16_t x = 0; x < width; x += 2) for (uint16_t x = 0; x < width; x += 2)
@ -586,15 +538,8 @@ void ZTexture::PrepareRawDataPalette4(const fs::path& palPath)
} }
} }
void ZTexture::PrepareRawDataPalette8(const fs::path& palPath) void ZTexture::PrepareRawDataPalette8()
{ {
textureData.ReadPng(palPath);
width = textureData.GetWidth();
height = textureData.GetHeight();
textureDataRaw.clear();
textureDataRaw.resize(GetRawDataSize());
for (uint16_t y = 0; y < height; y++) for (uint16_t y = 0; y < height; y++)
{ {
for (uint16_t x = 0; x < width; x++) for (uint16_t x = 0; x < width; x++)

18
tools/ZAPD/ZAPD/ZTexture.h
View File

@ -40,15 +40,15 @@ protected:
void PrepareBitmapPalette8(); void PrepareBitmapPalette8();
void PrepareRawDataFromFile(const fs::path& inFolder); void PrepareRawDataFromFile(const fs::path& inFolder);
void PrepareRawDataRGBA16(const fs::path& rgbaPath); void PrepareRawDataRGBA16();
void PrepareRawDataRGBA32(const fs::path& rgbaPath); void PrepareRawDataRGBA32();
void PrepareRawDataGrayscale4(const fs::path& grayPath); void PrepareRawDataGrayscale4();
void PrepareRawDataGrayscale8(const fs::path& grayPath); void PrepareRawDataGrayscale8();
void PrepareRawDataGrayscaleAlpha4(const fs::path& grayAlphaPath); void PrepareRawDataGrayscaleAlpha4();
void PrepareRawDataGrayscaleAlpha8(const fs::path& grayAlphaPath); void PrepareRawDataGrayscaleAlpha8();
void PrepareRawDataGrayscaleAlpha16(const fs::path& grayAlphaPath); void PrepareRawDataGrayscaleAlpha16();
void PrepareRawDataPalette4(const fs::path& palPath); void PrepareRawDataPalette4();
void PrepareRawDataPalette8(const fs::path& palPath); void PrepareRawDataPalette8();
public: public:
ZTexture(ZFile* nParent); ZTexture(ZFile* nParent);

218
tools/ZAPD/ZAPDUtils/Utils/BitConverter.h
View File

@ -1,155 +1,155 @@
#pragma once #pragma once
#include <cinttypes>
#include <cstdint> #include <cstdint>
#include <cstdio>
#include <limits> #include <limits>
#include <vector> #include <vector>
#define ALIGN8(val) (((val) + 7) & ~7)
#define ALIGN16(val) (((val) + 0xF) & ~0xF)
#define ALIGN64(val) (((val) + 0x3F) & ~0x3F)
class BitConverter class BitConverter
{ {
public: public:
static inline int8_t ToInt8BE(const uint8_t* data, int32_t offset) static inline int8_t ToInt8BE(const std::vector<uint8_t>& data, size_t offset)
{ {
return (uint8_t)data[offset + 0]; if (offset + 0 > data.size())
{
fprintf(stderr, "%s\n", __PRETTY_FUNCTION__);
fprintf(stderr, "Error: Trying a out-of-bounds reading from a data buffer\n");
fprintf(stderr, "\t Buffer size: 0x%zX\n", data.size());
fprintf(stderr, "\t Trying to read at offset: 0x%zX\n", offset);
}
return (int8_t)data.at(offset + 0);
} }
static inline int8_t ToInt8BE(const std::vector<uint8_t>& data, int32_t offset) static inline uint8_t ToUInt8BE(const std::vector<uint8_t>& data, size_t offset)
{ {
return (uint8_t)data[offset + 0]; if (offset + 0 > data.size())
{
fprintf(stderr, "%s\n", __PRETTY_FUNCTION__);
fprintf(stderr, "Error: Trying an out-of-bounds reading from a data buffer\n");
fprintf(stderr, "\t Buffer size: 0x%zX\n", data.size());
fprintf(stderr, "\t Trying to read at offset: 0x%zX\n", offset);
}
return (uint8_t)data.at(offset + 0);
} }
static inline uint8_t ToUInt8BE(const uint8_t* data, int32_t offset) static inline int16_t ToInt16BE(const std::vector<uint8_t>& data, size_t offset)
{ {
return (uint8_t)data[offset + 0]; if (offset + 1 > data.size())
{
fprintf(stderr, "%s\n", __PRETTY_FUNCTION__);
fprintf(stderr, "Error: Trying a out-of-bounds reading from a data buffer\n");
fprintf(stderr, "\t Buffer size: 0x%zX\n", data.size());
fprintf(stderr, "\t Trying to read at offset: 0x%zX\n", offset);
}
return ((uint16_t)data.at(offset + 0) << 8) + (uint16_t)data.at(offset + 1);
} }
static inline uint8_t ToUInt8BE(const std::vector<uint8_t>& data, int32_t offset) static inline uint16_t ToUInt16BE(const std::vector<uint8_t>& data, size_t offset)
{ {
return (uint8_t)data[offset + 0]; if (offset + 1 > data.size())
{
fprintf(stderr, "%s\n", __PRETTY_FUNCTION__);
fprintf(stderr, "Error: Trying a out-of-bounds reading from a data buffer\n");
fprintf(stderr, "\t Buffer size: 0x%zX\n", data.size());
fprintf(stderr, "\t Trying to read at offset: 0x%zX\n", offset);
}
return ((uint16_t)data.at(offset + 0) << 8) + (uint16_t)data.at(offset + 1);
} }
static inline int16_t ToInt16BE(const uint8_t* data, int32_t offset) static inline int32_t ToInt32BE(const std::vector<uint8_t>& data, size_t offset)
{ {
return ((uint16_t)data[offset + 0] << 8) + (uint16_t)data[offset + 1]; if (offset + 3 > data.size())
{
fprintf(stderr, "%s\n", __PRETTY_FUNCTION__);
fprintf(stderr, "Error: Trying a out-of-bounds reading from a data buffer\n");
fprintf(stderr, "\t Buffer size: 0x%zX\n", data.size());
fprintf(stderr, "\t Trying to read at offset: 0x%zX\n", offset);
}
return ((uint32_t)data.at(offset + 0) << 24) + ((uint32_t)data.at(offset + 1) << 16) +
((uint32_t)data.at(offset + 2) << 8) + (uint32_t)data.at(offset + 3);
} }
static inline int16_t ToInt16BE(const std::vector<uint8_t>& data, int32_t offset) static inline uint32_t ToUInt32BE(const std::vector<uint8_t>& data, size_t offset)
{ {
return ((uint16_t)data[offset + 0] << 8) + (uint16_t)data[offset + 1]; if (offset + 3 > data.size())
{
fprintf(stderr, "%s\n", __PRETTY_FUNCTION__);
fprintf(stderr, "Error: Trying a out-of-bounds reading from a data buffer\n");
fprintf(stderr, "\t Buffer size: 0x%zX\n", data.size());
fprintf(stderr, "\t Trying to read at offset: 0x%zX\n", offset);
}
return ((uint32_t)data.at(offset + 0) << 24) + ((uint32_t)data.at(offset + 1) << 16) +
((uint32_t)data.at(offset + 2) << 8) + (uint32_t)data.at(offset + 3);
} }
static inline uint16_t ToUInt16BE(const uint8_t* data, int32_t offset) static inline int64_t ToInt64BE(const std::vector<uint8_t>& data, size_t offset)
{ {
return ((uint16_t)data[offset + 0] << 8) + (uint16_t)data[offset + 1]; if (offset + 7 > data.size())
{
fprintf(stderr, "%s\n", __PRETTY_FUNCTION__);
fprintf(stderr, "Error: Trying a out-of-bounds reading from a data buffer\n");
fprintf(stderr, "\t Buffer size: 0x%zX\n", data.size());
fprintf(stderr, "\t Trying to read at offset: 0x%zX\n", offset);
}
return ((uint64_t)data.at(offset + 0) << 56) + ((uint64_t)data.at(offset + 1) << 48) +
((uint64_t)data.at(offset + 2) << 40) + ((uint64_t)data.at(offset + 3) << 32) +
((uint64_t)data.at(offset + 4) << 24) + ((uint64_t)data.at(offset + 5) << 16) +
((uint64_t)data.at(offset + 6) << 8) + ((uint64_t)data.at(offset + 7));
} }
static inline uint16_t ToUInt16BE(const std::vector<uint8_t>& data, int32_t offset) static inline uint64_t ToUInt64BE(const std::vector<uint8_t>& data, size_t offset)
{ {
return ((uint16_t)data[offset + 0] << 8) + (uint16_t)data[offset + 1]; if (offset + 7 > data.size())
{
fprintf(stderr, "%s\n", __PRETTY_FUNCTION__);
fprintf(stderr, "Error: Trying a out-of-bounds reading from a data buffer\n");
fprintf(stderr, "\t Buffer size: 0x%zX\n", data.size());
fprintf(stderr, "\t Trying to read at offset: 0x%zX\n", offset);
}
return ((uint64_t)data.at(offset + 0) << 56) + ((uint64_t)data.at(offset + 1) << 48) +
((uint64_t)data.at(offset + 2) << 40) + ((uint64_t)data.at(offset + 3) << 32) +
((uint64_t)data.at(offset + 4) << 24) + ((uint64_t)data.at(offset + 5) << 16) +
((uint64_t)data.at(offset + 6) << 8) + ((uint64_t)data.at(offset + 7));
} }
static inline int32_t ToInt32BE(const uint8_t* data, int32_t offset) static inline float ToFloatBE(const std::vector<uint8_t>& data, size_t offset)
{
return ((uint32_t)data[offset + 0] << 24) + ((uint32_t)data[offset + 1] << 16) +
((uint32_t)data[offset + 2] << 8) + (uint32_t)data[offset + 3];
}
static inline int32_t ToInt32BE(const std::vector<uint8_t>& data, int32_t offset)
{
return ((uint32_t)data[offset + 0] << 24) + ((uint32_t)data[offset + 1] << 16) +
((uint32_t)data[offset + 2] << 8) + (uint32_t)data[offset + 3];
}
static inline uint32_t ToUInt32BE(const uint8_t* data, int32_t offset)
{
return ((uint32_t)data[offset + 0] << 24) + ((uint32_t)data[offset + 1] << 16) +
((uint32_t)data[offset + 2] << 8) + (uint32_t)data[offset + 3];
}
static inline uint32_t ToUInt32BE(const std::vector<uint8_t>& data, int32_t offset)
{
return ((uint32_t)data[offset + 0] << 24) + ((uint32_t)data[offset + 1] << 16) +
((uint32_t)data[offset + 2] << 8) + (uint32_t)data[offset + 3];
}
static inline int64_t ToInt64BE(const uint8_t* data, int32_t offset)
{
return ((uint64_t)data[offset + 0] << 56) + ((uint64_t)data[offset + 1] << 48) +
((uint64_t)data[offset + 2] << 40) + ((uint64_t)data[offset + 3] << 32) +
((uint64_t)data[offset + 4] << 24) + ((uint64_t)data[offset + 5] << 16) +
((uint64_t)data[offset + 6] << 8) + ((uint64_t)data[offset + 7]);
}
static inline int64_t ToInt64BE(const std::vector<uint8_t>& data, int32_t offset)
{
return ((uint64_t)data[offset + 0] << 56) + ((uint64_t)data[offset + 1] << 48) +
((uint64_t)data[offset + 2] << 40) + ((uint64_t)data[offset + 3] << 32) +
((uint64_t)data[offset + 4] << 24) + ((uint64_t)data[offset + 5] << 16) +
((uint64_t)data[offset + 6] << 8) + ((uint64_t)data[offset + 7]);
}
static inline uint64_t ToUInt64BE(const uint8_t* data, int32_t offset)
{
return ((uint64_t)data[offset + 0] << 56) + ((uint64_t)data[offset + 1] << 48) +
((uint64_t)data[offset + 2] << 40) + ((uint64_t)data[offset + 3] << 32) +
((uint64_t)data[offset + 4] << 24) + ((uint64_t)data[offset + 5] << 16) +
((uint64_t)data[offset + 6] << 8) + ((uint64_t)data[offset + 7]);
}
static inline uint64_t ToUInt64BE(const std::vector<uint8_t>& data, int32_t offset)
{
return ((uint64_t)data[offset + 0] << 56) + ((uint64_t)data[offset + 1] << 48) +
((uint64_t)data[offset + 2] << 40) + ((uint64_t)data[offset + 3] << 32) +
((uint64_t)data[offset + 4] << 24) + ((uint64_t)data[offset + 5] << 16) +
((uint64_t)data[offset + 6] << 8) + ((uint64_t)data[offset + 7]);
}
static inline float ToFloatBE(const uint8_t* data, int32_t offset)
{ {
if (offset + 3 > data.size())
{
fprintf(stderr, "%s\n", __PRETTY_FUNCTION__);
fprintf(stderr, "Error: Trying a out-of-bounds reading from a data buffer\n");
fprintf(stderr, "\t Buffer size: 0x%zX\n", data.size());
fprintf(stderr, "\t Trying to read at offset: 0x%zX\n", offset);
}
float value; float value;
uint32_t floatData = ((uint32_t)data[offset + 0] << 24) + uint32_t floatData = ((uint32_t)data.at(offset + 0) << 24) +
((uint32_t)data[offset + 1] << 16) + ((uint32_t)data.at(offset + 1) << 16) +
((uint32_t)data[offset + 2] << 8) + (uint32_t)data[offset + 3]; ((uint32_t)data.at(offset + 2) << 8) + (uint32_t)data.at(offset + 3);
static_assert(sizeof(uint32_t) == sizeof(float), "expected 32-bit float"); static_assert(sizeof(uint32_t) == sizeof(float), "expected 32-bit float");
std::memcpy(&value, &floatData, sizeof(value)); std::memcpy(&value, &floatData, sizeof(value));
return value; return value;
} }
static inline float ToFloatBE(const std::vector<uint8_t>& data, int32_t offset) static inline double ToDoubleBE(const std::vector<uint8_t>& data, size_t offset)
{
float value;
uint32_t floatData = ((uint32_t)data[offset + 0] << 24) +
((uint32_t)data[offset + 1] << 16) +
((uint32_t)data[offset + 2] << 8) + (uint32_t)data[offset + 3];
static_assert(sizeof(uint32_t) == sizeof(float), "expected 32-bit float");
std::memcpy(&value, &floatData, sizeof(value));
return value;
}
static inline double ToDoubleBE(const uint8_t* data, int32_t offset)
{ {
if (offset + 7 > data.size())
{
fprintf(stderr, "%s\n", __PRETTY_FUNCTION__);
fprintf(stderr, "Error: Trying a out-of-bounds reading from a data buffer\n");
fprintf(stderr, "\t Buffer size: 0x%zX\n", data.size());
fprintf(stderr, "\t Trying to read at offset: 0x%zX\n", offset);
}
double value; double value;
uint64_t floatData = uint64_t floatData =
((uint64_t)data[offset + 0] << 56) + ((uint64_t)data[offset + 1] << 48) + ((uint64_t)data.at(offset + 0) << 56) + ((uint64_t)data.at(offset + 1) << 48) +
((uint64_t)data[offset + 2] << 40) + ((uint64_t)data[offset + 3] << 32) + ((uint64_t)data.at(offset + 2) << 40) + ((uint64_t)data.at(offset + 3) << 32) +
((uint64_t)data[offset + 4] << 24) + ((uint64_t)data[offset + 5] << 16) + ((uint64_t)data.at(offset + 4) << 24) + ((uint64_t)data.at(offset + 5) << 16) +
((uint64_t)data[offset + 6] << 8) + ((uint64_t)data[offset + 7]); ((uint64_t)data.at(offset + 6) << 8) + ((uint64_t)data.at(offset + 7));
static_assert(sizeof(uint64_t) == sizeof(double), "expected 64-bit double");
// Checks if the float format on the platform the ZAPD binary is running on supports the
// same float format as the object file.
static_assert(std::numeric_limits<float>::is_iec559,
"expected IEC559 floats on host machine");
std::memcpy(&value, &floatData, sizeof(value));
return value;
}
static inline double ToDoubleBE(const std::vector<uint8_t>& data, int32_t offset)
{
double value;
uint64_t floatData =
((uint64_t)data[offset + 0] << 56) + ((uint64_t)data[offset + 1] << 48) +
((uint64_t)data[offset + 2] << 40) + ((uint64_t)data[offset + 3] << 32) +
((uint64_t)data[offset + 4] << 24) + ((uint64_t)data[offset + 5] << 16) +
((uint64_t)data[offset + 6] << 8) + ((uint64_t)data[offset + 7]);
static_assert(sizeof(uint64_t) == sizeof(double), "expected 64-bit double"); static_assert(sizeof(uint64_t) == sizeof(double), "expected 64-bit double");
// Checks if the float format on the platform the ZAPD binary is running on supports the // Checks if the float format on the platform the ZAPD binary is running on supports the
// same float format as the object file. // same float format as the object file.

7
tools/ZAPD/ZAPDUtils/Utils/StringHelper.h
View File

@ -106,6 +106,13 @@ public:
return std::all_of(str.begin(), str.end(), ::isdigit); return std::all_of(str.begin(), str.end(), ::isdigit);
} }
static std::string ToUpper(const std::string& str)
{
std::string buff = str;
std::transform(buff.begin(), buff.end(), buff.begin(), ::toupper);
return buff;
}
static bool IEquals(const std::string& a, const std::string& b) static bool IEquals(const std::string& a, const std::string& b)
{ {
return std::equal(a.begin(), a.end(), b.begin(), b.end(), return std::equal(a.begin(), a.end(), b.begin(), b.end(),

15
tools/ZAPD/docs/zapd_extraction_xml_reference.md
View File

@ -382,6 +382,13 @@ Useful only for the unused `object_human`'s animation data.
- `Name`: Required. Suxffixed by `Skel`. - `Name`: Required. Suxffixed by `Skel`.
- `Type`: Required. Valid values: `Normal`, `Flex` and `Curve`. - `Type`: Required. Valid values: `Normal`, `Flex` and `Curve`.
- `LimbType`: Required. Valid values: `Standard`, `LOD`, `Skin`, `Curve` and `Legacy`. - `LimbType`: Required. Valid values: `Standard`, `LOD`, `Skin`, `Curve` and `Legacy`.
- `EnumName`: Optional. The name of `typedef`'d limb enum.
- `LimbNone`: Optional. The name of the limb with index zero in the limb enum.
- `LimbMax`: Optional. The name of the max limb index in the limb enum.
ZAPD is able to generate a limb enum by itself only if all the required data is provided. Providing some but not all the required data would trigger an error and the execution will halt.
The required data is providing the `EnumName`, `LimbNone` and `LimbMax` attributes in the `Skeleton` or `LimbTable` node and the `EnumName` attribute in every `Limb` of this skeleton.
※ There are no restrictions in the `Type` and `LimbType` attributes besides the valid values, so any skeleton type can be combined with any limb type. ※ There are no restrictions in the `Type` and `LimbType` attributes besides the valid values, so any skeleton type can be combined with any limb type.
@ -400,6 +407,11 @@ Useful only for the unused `object_human`'s animation data.
- `Name`: Required. Suxffixed by `Skel`. - `Name`: Required. Suxffixed by `Skel`.
- `LimbType`: Required. Valid values: `Standard`, `LOD`, `Skin`, `Curve` and `Legacy`. - `LimbType`: Required. Valid values: `Standard`, `LOD`, `Skin`, `Curve` and `Legacy`.
- `Count`: Required. Amount of limbs. Integer. - `Count`: Required. Amount of limbs. Integer.
- `EnumName`: Optional. The name of `typedef`'d limb enum.
- `LimbNone`: Optional. The name of the limb with index zero in the limb enum.
- `LimbMax`: Optional. The name of the max limb index in the limb enum.
See [Skeleton](#skeleton) for info on the limb enum generation.
------------------------- -------------------------
@ -415,6 +427,9 @@ Useful only for the unused `object_human`'s animation data.
- `Name`: Required. Suxffixed by `Limb`. - `Name`: Required. Suxffixed by `Limb`.
- `LimbType`: Required. Valid values: `Standard`, `LOD`, `Skin`, `Curve` and `Legacy`. - `LimbType`: Required. Valid values: `Standard`, `LOD`, `Skin`, `Curve` and `Legacy`.
- `EnumName`: Optional. The name used for this limb in the limbs enum. It must be either present in every limb or in none.
See [Skeleton](#skeleton) for info on the limb enum generation.
------------------------- -------------------------