mirror
/
Shipwright
mirror of https://github.com/HarbourMasters/Shipwright.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Shipwright/ZAPDTR/ZAPD/ZCutscene.cpp

1261 lines
36 KiB
C++
Raw Blame History

#include "ZCutscene.h"
#include "Utils/BitConverter.h"
#include "Utils/StringHelper.h"
#include "WarningHandler.h"
#include "ZResource.h"
REGISTER_ZFILENODE(Cutscene, ZCutscene);
ZCutscene::ZCutscene(ZFile* nParent) : ZCutsceneBase(nParent)
{
genOTRDef = true;
}
ZCutscene::~ZCutscene()
{
for (CutsceneCommand* cmd : commands)
delete cmd;
}
CutsceneCommandSetCameraPos::~CutsceneCommandSetCameraPos()
{
for (auto e : entries)
delete e;
}
CutsceneCommandSpecialAction::~CutsceneCommandSpecialAction()
{
for (auto e : entries)
delete e;
}
CutsceneCommandFadeBGM::~CutsceneCommandFadeBGM()
{
for (auto e : entries)
delete e;
}
CutsceneCommandPlayBGM::~CutsceneCommandPlayBGM()
{
for (auto e : entries)
delete e;
}
CutsceneCommandStopBGM::~CutsceneCommandStopBGM()
{
for (auto e : entries)
delete e;
}
CutsceneCommandEnvLighting::~CutsceneCommandEnvLighting()
{
for (auto e : entries)
delete e;
}
CutsceneCommandUnknown9::~CutsceneCommandUnknown9()
{
for (auto e : entries)
delete e;
}
CutsceneCommandUnknown::~CutsceneCommandUnknown()
{
for (auto e : entries)
delete e;
}
CutsceneCommandDayTime::~CutsceneCommandDayTime()
{
for (auto e : entries)
delete e;
}
CutsceneCommandTextbox::~CutsceneCommandTextbox()
{
for (auto e : entries)
delete e;
}
CutsceneCommandActorAction::~CutsceneCommandActorAction()
{
for (auto e : entries)
delete e;
}
CutsceneCommandSceneTransFX::~CutsceneCommandSceneTransFX()
{
}
std::string ZCutscene::GetBodySourceCode() const
{
std::string output = "";
uint32_t curPtr = 0;
output += StringHelper::Sprintf(" CS_BEGIN_CUTSCENE(%i, %i),\n", commands.size(), endFrame);
for (size_t i = 0; i < commands.size(); i++)
{
CutsceneCommand* cmd = commands[i];
output += " " + cmd->GenerateSourceCode(curPtr);
curPtr += cmd->GetCommandSize();
}
output += StringHelper::Sprintf(" CS_END(),\n", commands.size(), endFrame);
return output;
}
size_t ZCutscene::GetRawDataSize() const
{
size_t size = 0;
// Beginning
size += 8;
for (size_t i = 0; i < commands.size(); i++)
{
CutsceneCommand* cmd = commands[i];
size += cmd->GetCommandSize();
size += 4;
}
// End
size += 8;
return size;
}
void ZCutscene::ParseRawData()
{
ZResource::ParseRawData();
const auto& rawData = parent->GetRawData();
numCommands = BitConverter::ToInt32BE(rawData, rawDataIndex + 0);
commands = std::vector<CutsceneCommand*>();
endFrame = BitConverter::ToInt32BE(rawData, rawDataIndex + 4);
uint32_t currentPtr = rawDataIndex + 8;
for (int32_t i = 0; i < numCommands; i++)
{
int32_t id = BitConverter::ToInt32BE(rawData, currentPtr);
if (id == -1)
break;
CutsceneCommands cmdID = (CutsceneCommands)GetCommandFromID(id);
currentPtr += 4;
int32_t numEntries = 1;
for (int32_t j = 0; j < numEntries; j++)
{
CutsceneCommand* cmd = nullptr;
switch (cmdID)
{
case CutsceneCommands::Cmd00:
break;
case CutsceneCommands::SetCameraPos:
cmd = new CutsceneCommandSetCameraPos(rawData, currentPtr);
break;
case CutsceneCommands::SetCameraFocus:
cmd = new CutsceneCommandSetCameraPos(rawData, currentPtr);
break;
case CutsceneCommands::SpecialAction:
cmd = new CutsceneCommandSpecialAction(rawData, currentPtr);
break;
case CutsceneCommands::SetLighting:
cmd = new CutsceneCommandEnvLighting(rawData, currentPtr);
break;
case CutsceneCommands::SetCameraPosLink:
cmd = new CutsceneCommandSetCameraPos(rawData, currentPtr);
break;
case CutsceneCommands::SetCameraFocusLink:
cmd = new CutsceneCommandSetCameraPos(rawData, currentPtr);
break;
case CutsceneCommands::Cmd07:
break;
case CutsceneCommands::Cmd08:
break;
case CutsceneCommands::Cmd09:
cmd = new CutsceneCommandUnknown9(rawData, currentPtr);
break;
case CutsceneCommands::Textbox:
cmd = new CutsceneCommandTextbox(rawData, currentPtr);
break;
case CutsceneCommands::Unknown:
cmd = new CutsceneCommandUnknown(rawData, currentPtr);
break;
case CutsceneCommands::SetActorAction0:
case CutsceneCommands::SetActorAction1:
case CutsceneCommands::SetActorAction2:
case CutsceneCommands::SetActorAction3:
case CutsceneCommands::SetActorAction4:
case CutsceneCommands::SetActorAction5:
case CutsceneCommands::SetActorAction6:
case CutsceneCommands::SetActorAction7:
case CutsceneCommands::SetActorAction8:
case CutsceneCommands::SetActorAction9:
case CutsceneCommands::SetActorAction10:
cmd = new CutsceneCommandActorAction(rawData, currentPtr);
break;
case CutsceneCommands::SetSceneTransFX:
cmd = new CutsceneCommandSceneTransFX(rawData, currentPtr);
break;
case CutsceneCommands::Nop:
cmd = new CutsceneCommandNop(rawData, currentPtr);
break;
case CutsceneCommands::PlayBGM:
cmd = new CutsceneCommandPlayBGM(rawData, currentPtr);
break;
case CutsceneCommands::StopBGM:
cmd = new CutsceneCommandStopBGM(rawData, currentPtr);
break;
case CutsceneCommands::FadeBGM:
cmd = new CutsceneCommandFadeBGM(rawData, currentPtr);
break;
case CutsceneCommands::SetTime:
cmd = new CutsceneCommandDayTime(rawData, currentPtr);
break;
case CutsceneCommands::Terminator:
cmd = new CutsceneCommandTerminator(rawData, currentPtr);
break;
case CutsceneCommands::End:
cmd = new CutsceneCommandEnd(rawData, currentPtr);
break;
case CutsceneCommands::Error:
HANDLE_WARNING_RESOURCE(WarningType::NotImplemented, parent, this, rawDataIndex,
StringHelper::Sprintf("cutscene command error %d", cmdID),
"");
break;
}
cmd->commandIndex = i;
cmd->commandID = (uint32_t)id;
currentPtr += (uint32_t)cmd->GetCommandSize();
commands.push_back(cmd);
}
}
}
CutsceneCommands ZCutscene::GetCommandFromID(int32_t id)
{
switch (id)
{
case 0x0003:
return CutsceneCommands::SpecialAction;
case 0x0004:
return CutsceneCommands::SetLighting;
case 0x0056:
return CutsceneCommands::PlayBGM;
case 0x0057:
return CutsceneCommands::StopBGM;
case 0x007C:
return CutsceneCommands::FadeBGM;
case 0x0009:
return CutsceneCommands::Cmd09;
case 0x0013:
return CutsceneCommands::Textbox;
case 0x008C:
return CutsceneCommands::SetTime;
case 0x0001:
return CutsceneCommands::SetCameraPos;
case 0x0002:
return CutsceneCommands::SetCameraFocus;
case 0x0005:
return CutsceneCommands::SetCameraPosLink;
case 0x0006:
return CutsceneCommands::SetCameraFocusLink;
case 0x0007:
return CutsceneCommands::Cmd07;
case 0x0008:
return CutsceneCommands::Cmd08;
case 0x03E8:
return CutsceneCommands::Terminator;
case 0xFFFF:
return CutsceneCommands::End;
case 0x002D:
return CutsceneCommands::SetSceneTransFX;
case 10:
return CutsceneCommands::SetActorAction0;
case 15:
case 17:
case 18:
case 23:
case 34:
case 39:
case 46:
case 76:
case 85:
case 93:
case 105:
case 107:
case 110:
case 119:
case 123:
case 138:
case 139:
case 144:
return CutsceneCommands::SetActorAction1;
case 14:
case 16:
case 24:
case 35:
case 40:
case 48:
case 64:
case 68:
case 70:
case 78:
case 80:
case 94:
case 116:
case 118:
case 120:
case 125:
case 131:
case 141:
return CutsceneCommands::SetActorAction2;
case 25:
case 36:
case 41:
case 50:
case 67:
case 69:
case 72:
case 81:
case 106:
case 117:
case 121:
case 126:
case 132:
return CutsceneCommands::SetActorAction3;
case 29:
case 37:
case 42:
case 51:
case 53:
case 63:
case 65:
case 66:
case 75:
case 82:
case 108:
case 127:
case 133:
return CutsceneCommands::SetActorAction4;
case 30:
case 38:
case 43:
case 47:
case 54:
case 79:
case 83:
case 128:
case 135:
return CutsceneCommands::SetActorAction5;
case 44:
case 55:
case 77:
case 84:
case 90:
case 129:
case 136:
return CutsceneCommands::SetActorAction6;
case 31:
case 52:
case 57:
case 58:
case 88:
case 115:
case 130:
case 137:
return CutsceneCommands::SetActorAction7;
case 49:
case 60:
case 89:
case 111:
case 114:
case 134:
case 142:
return CutsceneCommands::SetActorAction8;
case 62:
return CutsceneCommands::SetActorAction9;
case 143:
return CutsceneCommands::SetActorAction10;
case 0x0B:
case 0x0D:
case 0x1A:
case 0x1B:
case 0x1C:
case 0x20:
case 0x21:
case 0x3B:
case 0x3D:
case 0x47:
case 0x49:
case 0x6D:
case 0x15:
case 0x16:
case 0x70:
case 0x71:
case 0x4A:
return CutsceneCommands::Unknown;
}
HANDLE_WARNING_RESOURCE(
WarningType::NotImplemented, parent, this, rawDataIndex,
StringHelper::Sprintf("could not identify cutscene command. ID 0x%04X", id), "");
return CutsceneCommands::Error;
}
ZResourceType ZCutscene::GetResourceType() const
{
return ZResourceType::Cutscene;
}
CutsceneCommand::CutsceneCommand([[maybe_unused]] const std::vector<uint8_t>& rawData,
[[maybe_unused]] uint32_t rawDataIndex)
{
}
CutsceneCommand::~CutsceneCommand()
{
}
std::string CutsceneCommand::GetCName()
{
return "SCmdCutsceneData";
}
std::string CutsceneCommand::GenerateSourceCode(uint32_t baseAddress)
{
return StringHelper::Sprintf("%s CutsceneData%04XCmd%02X = { 0x%02X,", GetCName().c_str(),
baseAddress, commandIndex, commandID);
}
size_t CutsceneCommand::GetCommandSize()
{
return 4;
}
CutsceneCameraPoint::CutsceneCameraPoint(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex)
{
const uint8_t* data = rawData.data();
continueFlag = data[rawDataIndex + 0];
cameraRoll = data[rawDataIndex + 1];
nextPointFrame = BitConverter::ToInt16BE(data, rawDataIndex + 2);
viewAngle = BitConverter::ToFloatBE(data, rawDataIndex + 4);
posX = BitConverter::ToInt16BE(data, rawDataIndex + 8);
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,
uint32_t rawDataIndex)
: CutsceneCommand(rawData, rawDataIndex)
{
const uint8_t* data = rawData.data();
base = BitConverter::ToUInt16BE(data, rawDataIndex + 0);
startFrame = BitConverter::ToUInt16BE(data, rawDataIndex + 2);
endFrame = BitConverter::ToUInt16BE(data, rawDataIndex + 4);
unused = BitConverter::ToUInt16BE(data, rawDataIndex + 6);
entries = std::vector<CutsceneCameraPoint*>();
bool shouldContinue = true;
uint32_t currentPtr = rawDataIndex + 8;
while (shouldContinue)
{
CutsceneCameraPoint* camPoint = new CutsceneCameraPoint(rawData, currentPtr);
entries.push_back(camPoint);
if (camPoint->continueFlag == -1)
shouldContinue = false;
currentPtr += 16;
}
}
// TODO
std::string CutsceneCommandSetCameraPos::GetCName()
{
return "";
}
std::string CutsceneCommandSetCameraPos::GenerateSourceCode([[maybe_unused]] uint32_t baseAddress)
{
std::string result;
std::string listStr;
std::string posStr;
if (commandID == (int32_t)CutsceneCommands::SetCameraFocus)
{
listStr = "CS_CAM_FOCUS_POINT_LIST";
posStr = "CS_CAM_FOCUS_POINT";
}
else if (commandID == (int32_t)CutsceneCommands::SetCameraFocusLink)
{
listStr = "CS_CAM_FOCUS_POINT_PLAYER_LIST";
posStr = "CS_CAM_FOCUS_POINT_PLAYER";
}
else if (commandID == (int32_t)CutsceneCommands::SetCameraPosLink)
{
listStr = "CS_CAM_POS_PLAYER_LIST";
posStr = "CS_CAM_POS_PLAYER";
}
else
{
listStr = "CS_CAM_POS_LIST";
posStr = "CS_CAM_POS";
}
result += StringHelper::Sprintf("%s(%i, %i),\n", listStr.c_str(), startFrame, endFrame);
for (size_t i = 0; i < entries.size(); i++)
{
std::string continueMacro = "CS_CMD_CONTINUE";
if (entries[i]->continueFlag != 0)
continueMacro = "CS_CMD_STOP";
result += StringHelper::Sprintf(" %s(%s, 0x%02X, %i, %ff, %i, %i, %i, 0x%04X),\n",
posStr.c_str(), continueMacro.c_str(),
entries[i]->cameraRoll, entries[i]->nextPointFrame,
entries[i]->viewAngle, entries[i]->posX, entries[i]->posY,
entries[i]->posZ, entries[i]->unused);
}
return result;
}
size_t CutsceneCommandSetCameraPos::GetCommandSize()
{
return 8 + (entries.size() * 16);
}
MusicFadeEntry::MusicFadeEntry(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex)
{
base = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0);
startFrame = BitConverter::ToUInt16BE(rawData, rawDataIndex + 2);
endFrame = BitConverter::ToUInt16BE(rawData, rawDataIndex + 4);
unknown0 = BitConverter::ToUInt16BE(rawData, rawDataIndex + 6);
unknown1 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 8);
unknown2 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 12);
unknown3 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 16);
unknown4 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 20);
unknown5 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 24);
unknown6 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 28);
unknown7 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 32);
unknown8 = BitConverter::ToUInt32BE(rawData,
rawDataIndex + 36); // Macro hardcodes it as zero
unknown9 = BitConverter::ToUInt32BE(rawData,
rawDataIndex + 40); // Macro hardcodes it as zero
unknown10 = BitConverter::ToUInt32BE(rawData,
rawDataIndex + 44); // Macro hardcodes it as zero
}
CutsceneCommandFadeBGM::CutsceneCommandFadeBGM(const std::vector<uint8_t>& rawData,
uint32_t rawDataIndex)
: CutsceneCommand(rawData, rawDataIndex)
{
uint32_t numEntries = BitConverter::ToUInt32BE(rawData, rawDataIndex + 0);
rawDataIndex += 4;
for (uint32_t i = 0; i < numEntries; i++)
{
entries.push_back(new MusicFadeEntry(rawData, rawDataIndex));
rawDataIndex += 0x30;
}
}
std::string CutsceneCommandFadeBGM::GetCName()
{
return "CsCmdMusicFade";
}
std::string CutsceneCommandFadeBGM::GenerateSourceCode([[maybe_unused]] uint32_t baseAddress)
{
std::string result;
result += StringHelper::Sprintf("CS_FADE_BGM_LIST(%i),\n", entries.size());
for (size_t i = 0; i < entries.size(); i++)
{
result += StringHelper::Sprintf(
" CS_FADE_BGM(%i, %i, %i, %i, %i, %i, %i, %i, %i, %i, %i),\n", entries[i]->base,
entries[i]->startFrame, entries[i]->endFrame, entries[i]->unknown0,
entries[i]->unknown1, entries[i]->unknown2, entries[i]->unknown3, entries[i]->unknown4,
entries[i]->unknown5, entries[i]->unknown6, entries[i]->unknown7);
}
return result;
}
size_t CutsceneCommandFadeBGM::GetCommandSize()
{
return CutsceneCommand::GetCommandSize() + 0x30 * entries.size();
}
MusicChangeEntry::MusicChangeEntry(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex)
{
sequence = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0);
startFrame = BitConverter::ToUInt16BE(rawData, rawDataIndex + 2);
endFrame = BitConverter::ToUInt16BE(rawData, rawDataIndex + 4);
unknown0 = BitConverter::ToUInt16BE(rawData, rawDataIndex + 6);
unknown1 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 8);
unknown2 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 12);
unknown3 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 16);
unknown4 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 20);
unknown5 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 24);
unknown6 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 28);
unknown7 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 32);
}
CutsceneCommandPlayBGM::CutsceneCommandPlayBGM(const std::vector<uint8_t>& rawData,
uint32_t rawDataIndex)
: CutsceneCommand(rawData, rawDataIndex)
{
uint32_t numEntries = BitConverter::ToUInt32BE(rawData, rawDataIndex + 0);
rawDataIndex += 4;
for (uint32_t i = 0; i < numEntries; i++)
{
entries.push_back(new MusicChangeEntry(rawData, rawDataIndex));
rawDataIndex += 0x30;
}
}
std::string CutsceneCommandPlayBGM::GenerateSourceCode([[maybe_unused]] uint32_t baseAddress)
{
std::string result;
result += StringHelper::Sprintf("CS_PLAY_BGM_LIST(%i),\n", entries.size());
for (size_t i = 0; i < entries.size(); i++)
{
result += StringHelper::Sprintf(
" CS_PLAY_BGM(%i, %i, %i, %i, %i, %i, %i, %i, %i, %i, %i),\n",
entries[i]->sequence, entries[i]->startFrame, entries[i]->endFrame,
entries[i]->unknown0, entries[i]->unknown1, entries[i]->unknown2, entries[i]->unknown3,
entries[i]->unknown4, entries[i]->unknown5, entries[i]->unknown6, entries[i]->unknown7);
}
return result;
}
std::string CutsceneCommandPlayBGM::GetCName()
{
return "CsCmdMusicChange";
}
size_t CutsceneCommandPlayBGM::GetCommandSize()
{
return CutsceneCommand::GetCommandSize() + 0x30;
}
CutsceneCommandStopBGM::CutsceneCommandStopBGM(const std::vector<uint8_t>& rawData,
uint32_t rawDataIndex)
: CutsceneCommand(rawData, rawDataIndex)
{
uint32_t numEntries = BitConverter::ToUInt32BE(rawData, rawDataIndex + 0);
rawDataIndex += 4;
for (uint32_t i = 0; i < numEntries; i++)
{
entries.push_back(new MusicChangeEntry(rawData, rawDataIndex));
rawDataIndex += 0x30;
}
}
std::string CutsceneCommandStopBGM::GenerateSourceCode([[maybe_unused]] uint32_t baseAddress)
{
std::string result;
result += StringHelper::Sprintf("CS_STOP_BGM_LIST(%i),\n", entries.size());
for (size_t i = 0; i < entries.size(); i++)
{
result += StringHelper::Sprintf(
"\t\tCS_STOP_BGM(%i, %i, %i, %i, %i, %i, %i, %i, %i, %i, %i),\n", entries[i]->sequence,
entries[i]->startFrame, entries[i]->endFrame, entries[i]->unknown0,
entries[i]->unknown1, entries[i]->unknown2, entries[i]->unknown3, entries[i]->unknown4,
entries[i]->unknown5, entries[i]->unknown6, entries[i]->unknown7);
}
return result;
}
std::string CutsceneCommandStopBGM::GetCName()
{
return "CsCmdMusicChange";
}
size_t CutsceneCommandStopBGM::GetCommandSize()
{
return CutsceneCommand::GetCommandSize() + 0x30;
}
EnvLightingEntry::EnvLightingEntry(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex)
{
setting = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 0);
startFrame = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 2);
endFrame = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 4);
unused0 = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 6);
unused1 = (uint32_t)BitConverter::ToInt32BE(rawData, rawDataIndex + 8);
unused2 = (uint32_t)BitConverter::ToInt32BE(rawData, rawDataIndex + 12);
unused3 = (uint32_t)BitConverter::ToInt32BE(rawData, rawDataIndex + 16);
unused4 = (uint32_t)BitConverter::ToInt32BE(rawData, rawDataIndex + 20);
unused5 = (uint32_t)BitConverter::ToInt32BE(rawData, rawDataIndex + 24);
unused6 = (uint32_t)BitConverter::ToInt32BE(rawData, rawDataIndex + 28);
unused7 = (uint32_t)BitConverter::ToInt32BE(rawData, rawDataIndex + 32);
}
CutsceneCommandEnvLighting::CutsceneCommandEnvLighting(const std::vector<uint8_t>& rawData,
uint32_t rawDataIndex)
: CutsceneCommand(rawData, rawDataIndex)
{
int32_t numEntries = BitConverter::ToInt32BE(rawData, rawDataIndex + 0);
rawDataIndex += 4;
for (int32_t i = 0; i < numEntries; i++)
{
entries.push_back(new EnvLightingEntry(rawData, rawDataIndex));
rawDataIndex += 0x30;
}
}
std::string CutsceneCommandEnvLighting::GenerateSourceCode([[maybe_unused]] uint32_t baseAddress)
{
std::string result;
result += StringHelper::Sprintf("CS_LIGHTING_LIST(%i),\n", entries.size());
for (size_t i = 0; i < entries.size(); i++)
{
result += StringHelper::Sprintf(
"\t\tCS_LIGHTING(%i, %i, %i, %i, %i, %i, %i, %i, %i, %i, %i),\n", entries[i]->setting,
entries[i]->startFrame, entries[i]->endFrame, entries[i]->unused0, entries[i]->unused1,
entries[i]->unused2, entries[i]->unused3, entries[i]->unused4, entries[i]->unused5,
entries[i]->unused6, entries[i]->unused7);
}
return result;
}
std::string CutsceneCommandEnvLighting::GetCName()
{
return "CsCmdEnvLighting";
}
size_t CutsceneCommandEnvLighting::GetCommandSize()
{
return CutsceneCommand::GetCommandSize() + (0x30 * entries.size());
}
Unknown9Entry::Unknown9Entry(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex)
{
base = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 0);
startFrame = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 2);
endFrame = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 4);
unk2 = rawData[rawDataIndex + 6];
unk3 = rawData[rawDataIndex + 7];
unk4 = rawData[rawDataIndex + 8];
unused0 = rawData[rawDataIndex + 10];
unused1 = rawData[rawDataIndex + 11];
;
}
CutsceneCommandUnknown9::CutsceneCommandUnknown9(const std::vector<uint8_t>& rawData,
uint32_t rawDataIndex)
: CutsceneCommand(rawData, rawDataIndex)
{
int32_t numEntries = BitConverter::ToInt32BE(rawData, rawDataIndex);
rawDataIndex += 4;
for (int32_t i = 0; i < numEntries; i++)
{
entries.push_back(new Unknown9Entry(rawData, rawDataIndex));
rawDataIndex += 0x0C;
}
}
std::string CutsceneCommandUnknown9::GenerateSourceCode([[maybe_unused]] uint32_t baseAddress)
{
std::string result;
result += StringHelper::Sprintf("CS_CMD_09_LIST(%i),\n", entries.size());
for (size_t i = 0; i < entries.size(); i++)
{
result += StringHelper::Sprintf("\t\tCS_CMD_09(%i, %i, %i, %i, %i, %i, %i, %i),\n",
entries[i]->base, entries[i]->startFrame,
entries[i]->endFrame, entries[i]->unk2, entries[i]->unk3,
entries[i]->unk4, entries[i]->unused0, entries[i]->unused1);
}
return result;
}
std::string CutsceneCommandUnknown9::GetCName()
{
return "CsCmdUnknown9";
}
size_t CutsceneCommandUnknown9::GetCommandSize()
{
return CutsceneCommand::GetCommandSize() + (entries.size() * 12);
}
UnkEntry::UnkEntry(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex)
{
unused0 = (uint32_t)BitConverter::ToInt32BE(rawData, rawDataIndex + 0);
unused1 = (uint32_t)BitConverter::ToInt32BE(rawData, rawDataIndex + 4);
unused2 = (uint32_t)BitConverter::ToInt32BE(rawData, rawDataIndex + 8);
unused3 = (uint32_t)BitConverter::ToInt32BE(rawData, rawDataIndex + 12);
unused4 = (uint32_t)BitConverter::ToInt32BE(rawData, rawDataIndex + 16);
unused5 = (uint32_t)BitConverter::ToInt32BE(rawData, rawDataIndex + 20);
unused6 = (uint32_t)BitConverter::ToInt32BE(rawData, rawDataIndex + 24);
unused7 = (uint32_t)BitConverter::ToInt32BE(rawData, rawDataIndex + 28);
unused8 = (uint32_t)BitConverter::ToInt32BE(rawData, rawDataIndex + 32);
unused9 = (uint32_t)BitConverter::ToInt32BE(rawData, rawDataIndex + 36);
unused10 = (uint32_t)BitConverter::ToInt32BE(rawData, rawDataIndex + 40);
unused11 = (uint32_t)BitConverter::ToInt32BE(rawData, rawDataIndex + 44);
}
CutsceneCommandUnknown::CutsceneCommandUnknown(const std::vector<uint8_t>& rawData,
uint32_t rawDataIndex)
: CutsceneCommand(rawData, rawDataIndex)
{
int32_t numEntries = BitConverter::ToInt32BE(rawData, rawDataIndex);
rawDataIndex += 4;
for (int32_t i = 0; i < numEntries; i++)
{
entries.push_back(new UnkEntry(rawData, rawDataIndex));
rawDataIndex += 0x30;
}
}
std::string CutsceneCommandUnknown::GenerateSourceCode([[maybe_unused]] uint32_t baseAddress)
{
std::string result;
result += StringHelper::Sprintf("CS_UNK_DATA_LIST(0x%02X, %i),\n", commandID, entries.size());
for (size_t i = 0; i < entries.size(); i++)
{
result += StringHelper::Sprintf(
" CS_UNK_DATA(%i, %i, %i, %i, %i, %i, %i, %i, %i, %i, %i, %i),\n",
entries[i]->unused0, entries[i]->unused1, entries[i]->unused2, entries[i]->unused3,
entries[i]->unused4, entries[i]->unused5, entries[i]->unused6, entries[i]->unused7,
entries[i]->unused8, entries[i]->unused9, entries[i]->unused10, entries[i]->unused11);
}
return result;
}
std::string CutsceneCommandUnknown::GetCName()
{
return "CsCmdUnknown1A";
}
size_t CutsceneCommandUnknown::GetCommandSize()
{
return CutsceneCommand::GetCommandSize() + (entries.size() * 0x30);
}
DayTimeEntry::DayTimeEntry(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex)
{
base = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 0);
startFrame = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 2);
endFrame = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 4);
hour = rawData[rawDataIndex + 6];
minute = rawData[rawDataIndex + 7];
unused = rawData[rawDataIndex + 8];
}
CutsceneCommandDayTime::CutsceneCommandDayTime(const std::vector<uint8_t>& rawData,
uint32_t rawDataIndex)
: CutsceneCommand(rawData, rawDataIndex)
{
int32_t numEntries = BitConverter::ToInt32BE(rawData, rawDataIndex);
rawDataIndex += 4;
for (int32_t i = 0; i < numEntries; i++)
{
entries.push_back(new DayTimeEntry(rawData, rawDataIndex));
rawDataIndex += 12;
}
}
std::string CutsceneCommandDayTime::GetCName()
{
return "CsCmdDayTime";
}
std::string CutsceneCommandDayTime::GenerateSourceCode([[maybe_unused]] uint32_t baseAddress)
{
std::string result;
result += StringHelper::Sprintf("CS_TIME_LIST(%i),\n", entries.size());
for (size_t i = 0; i < entries.size(); i++)
{
result += StringHelper::Sprintf(
" CS_TIME(%i, %i, %i, %i, %i, %i),\n", entries[i]->base, entries[i]->startFrame,
entries[i]->endFrame, entries[i]->hour, entries[i]->minute, entries[i]->unused);
}
return result;
}
size_t CutsceneCommandDayTime::GetCommandSize()
{
return CutsceneCommand::GetCommandSize() + (entries.size() * 12);
}
TextboxEntry::TextboxEntry(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex)
{
base = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 0);
startFrame = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 2);
endFrame = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 4);
type = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 6);
textID1 = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 8);
textID2 = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 10);
}
CutsceneCommandTextbox::CutsceneCommandTextbox(const std::vector<uint8_t>& rawData,
uint32_t rawDataIndex)
: CutsceneCommand(rawData, rawDataIndex)
{
int32_t numEntries = BitConverter::ToInt32BE(rawData, rawDataIndex);
rawDataIndex += 4;
for (int32_t i = 0; i < numEntries; i++)
{
entries.push_back(new TextboxEntry(rawData, rawDataIndex));
rawDataIndex += 12;
}
}
std::string CutsceneCommandTextbox::GetCName()
{
return "CsCmdTextbox";
}
std::string CutsceneCommandTextbox::GenerateSourceCode([[maybe_unused]] uint32_t baseAddress)
{
std::string result;
result += StringHelper::Sprintf("CS_TEXT_LIST(%i),\n", entries.size());
for (size_t i = 0; i < entries.size(); i++)
{
if (entries[i]->base == 0xFFFF)
{
result += StringHelper::Sprintf(" CS_TEXT_NONE(%i, %i),\n",
entries[i]->startFrame, entries[i]->endFrame);
}
else
{
result += StringHelper::Sprintf(
" CS_TEXT_DISPLAY_TEXTBOX(%i, %i, %i, %i, %i, %i),\n", entries[i]->base,
entries[i]->startFrame, entries[i]->endFrame, entries[i]->type, entries[i]->textID1,
entries[i]->textID2);
}
}
return result;
}
size_t CutsceneCommandTextbox::GetCommandSize()
{
return CutsceneCommand::GetCommandSize() + (entries.size() * 12);
}
ActorAction::ActorAction(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex)
{
const uint8_t* data = rawData.data();
action = (uint16_t)BitConverter::ToInt16BE(data, rawDataIndex + 0);
startFrame = (uint16_t)BitConverter::ToInt16BE(data, rawDataIndex + 2);
endFrame = (uint16_t)BitConverter::ToInt16BE(data, rawDataIndex + 4);
rotX = (uint16_t)BitConverter::ToInt16BE(data, rawDataIndex + 6);
rotY = (uint16_t)BitConverter::ToInt16BE(data, rawDataIndex + 8);
rotZ = (uint16_t)BitConverter::ToInt16BE(data, rawDataIndex + 10);
startPosX = BitConverter::ToInt32BE(data, rawDataIndex + 12);
startPosY = BitConverter::ToInt32BE(data, rawDataIndex + 16);
startPosZ = BitConverter::ToInt32BE(data, rawDataIndex + 20);
endPosX = BitConverter::ToInt32BE(data, rawDataIndex + 24);
endPosY = BitConverter::ToInt32BE(data, rawDataIndex + 28);
endPosZ = BitConverter::ToInt32BE(data, rawDataIndex + 32);
normalX = BitConverter::ToFloatBE(data, rawDataIndex + 36);
normalY = BitConverter::ToFloatBE(data, rawDataIndex + 40);
normalZ = BitConverter::ToFloatBE(data, rawDataIndex + 44);
}
CutsceneCommandActorAction::CutsceneCommandActorAction(const std::vector<uint8_t>& rawData,
uint32_t rawDataIndex)
: CutsceneCommand(rawData, rawDataIndex)
{
int32_t numEntries = BitConverter::ToInt32BE(rawData, rawDataIndex);
rawDataIndex += 4;
for (int32_t i = 0; i < numEntries; i++)
{
entries.push_back(new ActorAction(rawData, rawDataIndex));
rawDataIndex += 0x30;
}
}
std::string CutsceneCommandActorAction::GenerateSourceCode([[maybe_unused]] uint32_t baseAddress)
{
std::string result;
std::string subCommand;
if (commandID == 10)
{
result += StringHelper::Sprintf("CS_PLAYER_ACTION_LIST(%i),\n", entries.size());
subCommand = "CS_PLAYER_ACTION";
}
else
{
result += StringHelper::Sprintf("CS_NPC_ACTION_LIST(%i, %i),\n", commandID, entries.size());
subCommand = "CS_NPC_ACTION";
}
for (size_t i = 0; i < entries.size(); i++)
{
result += StringHelper::Sprintf(
"\t\t%s(0x%04X, %i, %i, 0x%04X, 0x%04X, 0x%04X, %i, %i, %i, %i, %i, %i, %.11ef, "
"%.11ef, %.11ef),\n",
subCommand.c_str(), entries[i]->action, entries[i]->startFrame, entries[i]->endFrame,
entries[i]->rotX, entries[i]->rotY, entries[i]->rotZ, entries[i]->startPosX,
entries[i]->startPosY, entries[i]->startPosZ, entries[i]->endPosX, entries[i]->endPosY,
entries[i]->endPosZ, entries[i]->normalX, entries[i]->normalY, entries[i]->normalZ);
}
return result;
}
std::string CutsceneCommandActorAction::GetCName()
{
return "CsCmdBase";
}
size_t CutsceneCommandActorAction::GetCommandSize()
{
return CutsceneCommand::GetCommandSize() + (entries.size() * 0x30);
}
CutsceneCommandTerminator::CutsceneCommandTerminator(const std::vector<uint8_t>& rawData,
uint32_t rawDataIndex)
: CutsceneCommand(rawData, rawDataIndex)
{
rawDataIndex += 4;
base = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 0);
startFrame = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 2);
endFrame = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 4);
unknown = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 6); // endFrame duplicate
}
std::string CutsceneCommandTerminator::GetCName()
{
return "CsCmdBase";
}
std::string CutsceneCommandTerminator::GenerateSourceCode([[maybe_unused]] uint32_t baseAddress)
{
std::string result;
result += StringHelper::Sprintf("CS_TERMINATOR(0x%04X, %i, %i),\n", base, startFrame, endFrame);
return result;
}
size_t CutsceneCommandTerminator::GetCommandSize()
{
return CutsceneCommand::GetCommandSize() + 8;
}
CutsceneCommandEnd::CutsceneCommandEnd(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex)
: CutsceneCommand(rawData, rawDataIndex)
{
base = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 0);
startFrame = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 2);
endFrame = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 4);
}
std::string CutsceneCommandEnd::GenerateSourceCode([[maybe_unused]] uint32_t baseAddress)
{
std::string result;
result += StringHelper::Sprintf("CS_END(),\n");
return result;
}
std::string CutsceneCommandEnd::GetCName()
{
return "CsCmdBase";
}
size_t CutsceneCommandEnd::GetCommandSize()
{
return CutsceneCommand::GetCommandSize() + 6;
}
SpecialActionEntry::SpecialActionEntry(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex)
{
const uint8_t* data = rawData.data();
base = BitConverter::ToUInt16BE(data, rawDataIndex + 0);
startFrame = BitConverter::ToUInt16BE(data, rawDataIndex + 2);
endFrame = BitConverter::ToUInt16BE(data, rawDataIndex + 4);
unused0 = BitConverter::ToUInt16BE(data, rawDataIndex + 6);
unused1 = BitConverter::ToUInt32BE(data, rawDataIndex + 8);
unused2 = BitConverter::ToUInt32BE(data, rawDataIndex + 12);
unused3 = BitConverter::ToUInt32BE(data, rawDataIndex + 16);
unused4 = BitConverter::ToUInt32BE(data, rawDataIndex + 20);
unused5 = BitConverter::ToUInt32BE(data, rawDataIndex + 24);
unused6 = BitConverter::ToUInt32BE(data, rawDataIndex + 28);
unused7 = BitConverter::ToUInt32BE(data, rawDataIndex + 32);
unused8 = BitConverter::ToUInt32BE(data, rawDataIndex + 36);
unused9 = BitConverter::ToUInt32BE(data, rawDataIndex + 40);
unused10 = BitConverter::ToUInt32BE(data, rawDataIndex + 44);
}
CutsceneCommandSpecialAction::CutsceneCommandSpecialAction(const std::vector<uint8_t>& rawData,
uint32_t rawDataIndex)
: CutsceneCommand(rawData, rawDataIndex)
{
int32_t numEntries = BitConverter::ToInt32BE(rawData, rawDataIndex + 0);
rawDataIndex += 4;
for (int32_t i = 0; i < numEntries; i++)
{
entries.push_back(new SpecialActionEntry(rawData, rawDataIndex));
rawDataIndex += 0x30;
}
}
std::string CutsceneCommandSpecialAction::GenerateSourceCode([[maybe_unused]] uint32_t baseAddress)
{
std::string result;
result += StringHelper::Sprintf("CS_MISC_LIST(%i),\n", entries.size());
for (size_t i = 0; i < entries.size(); i++)
{
result += StringHelper::Sprintf(
"\t\tCS_MISC(0x%04X, %i, %i, 0x%04X, 0x%04X, 0x%04X, %i, %i, %i, %i, %i, %i, %i, "
"%i),\n",
entries[i]->base, entries[i]->startFrame, entries[i]->endFrame, entries[i]->unused0,
entries[i]->unused1, entries[i]->unused2, entries[i]->unused3, entries[i]->unused4,
entries[i]->unused5, entries[i]->unused6, entries[i]->unused7, entries[i]->unused8,
entries[i]->unused9, entries[i]->unused10);
}
return result;
}
std::string CutsceneCommandSpecialAction::GetCName()
{
return "CsCmdBase";
}
size_t CutsceneCommandSpecialAction::GetCommandSize()
{
return CutsceneCommand::GetCommandSize() + (0x30 * entries.size());
}
CutsceneCommandNop::CutsceneCommandNop(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex)
: CutsceneCommand(rawData, rawDataIndex)
{
base = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 0);
startFrame = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 2);
endFrame = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 4);
}
std::string CutsceneCommandNop::GetCName()
{
return "CsCmdBase";
}
size_t CutsceneCommandNop::GetCommandSize()
{
return CutsceneCommand::GetCommandSize() + 6;
}
CutsceneCommandSceneTransFX::CutsceneCommandSceneTransFX(const std::vector<uint8_t>& rawData,
uint32_t rawDataIndex)
: CutsceneCommand(rawData, rawDataIndex)
{
rawDataIndex += 4;
base = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 0);
startFrame = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 2);
endFrame = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 4);
}
std::string CutsceneCommandSceneTransFX::GenerateSourceCode([[maybe_unused]] uint32_t baseAddress)
{
return StringHelper::Sprintf("CS_SCENE_TRANS_FX(%i, %i, %i),\n", base, startFrame, endFrame);
}
std::string CutsceneCommandSceneTransFX::GetCName()
{
return "CsCmdBase";
}
size_t CutsceneCommandSceneTransFX::GetCommandSize()
{
return CutsceneCommand::GetCommandSize() + 8;
}
ZCutsceneBase::ZCutsceneBase(ZFile* nParent) : ZResource(nParent)
{
}
Declaration* ZCutsceneBase::DeclareVar(const std::string& prefix, const std::string& bodyStr)
{
std::string auxName = name;
if (auxName == "")
auxName = GetDefaultName(prefix);
Declaration* decl =
parent->AddDeclarationArray(rawDataIndex, GetDeclarationAlignment(), GetRawDataSize(),
GetSourceTypeName(), auxName, 0, bodyStr);
decl->staticConf = staticConf;
return decl;
}
std::string ZCutsceneBase::GetSourceTypeName() const
{
return "CutsceneData";
}
Reference in New Issue View Git Blame Copy Permalink