mirror of
https://github.com/HarbourMasters/Shipwright.git
synced 2024-12-23 08:38:52 -05:00
5dda5762ba
subrepo: subdir: "ZAPDTR" merged: "a53a53ea4" upstream: origin: "https://github.com/HarbourMasters/ZAPDTR.git" branch: "master" commit: "a53a53ea4" git-subrepo: version: "0.4.1" origin: "???" commit: "???"
1261 lines
36 KiB
C++
1261 lines
36 KiB
C++
#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";
|
|
}
|