Implement CS Splines for MM (#310)

* wip

* Finished.

2 files changed, 186 insertions, 19 deletions

diff --git a/ZAPD/OtherStructs/CutsceneMM_Commands.cpp b/ZAPD/OtherStructs/CutsceneMM_Commands.cpp
index f18e313..c26b39c 100644
--- a/ZAPD/OtherStructs/CutsceneMM_Commands.cpp
+++ b/ZAPD/OtherStructs/CutsceneMM_Commands.cpp
@@ -4,6 +4,7 @@
 #include "Globals.h"
 #include "Utils/BitConverter.h"
 #include "Utils/StringHelper.h"
+#include "WarningHandler.h"
 
 /**** GENERIC ****/
 
@@ -126,42 +127,157 @@ std::string CutsceneMMCommand_GenericCmd::GetCommandMacro() const
 
 /**** CAMERA ****/
 
-CutsceneSubCommandEntry_Camera::CutsceneSubCommandEntry_Camera(const std::vector<uint8_t>& rawData,
-                                                               offset_t rawDataIndex)
-	: CutsceneSubCommandEntry(rawData, rawDataIndex)
+CutsceneSubCommandEntry_SplineCamPoint::CutsceneSubCommandEntry_SplineCamPoint(const std::vector<uint8_t>& rawData,
+                                                               offset_t rawDataIndex): CutsceneSubCommandEntry(rawData, rawDataIndex)
+{
+	interpType = BitConverter::ToUInt8BE(rawData, rawDataIndex + 0);
+	weight = BitConverter::ToUInt8BE(rawData, rawDataIndex + 1);
+	duration = BitConverter::ToUInt16BE(rawData, rawDataIndex + 2);
+	posX = BitConverter::ToUInt16BE(rawData, rawDataIndex + 4);
+	posY = BitConverter::ToUInt16BE(rawData, rawDataIndex + 6);
+	posZ = BitConverter::ToUInt16BE(rawData, rawDataIndex + 8);
+	relTo = BitConverter::ToUInt16BE(rawData, rawDataIndex + 10);
+	printf("%s\n", GetBodySourceCode().c_str());
+
+}
+/*#define CS_CAM_POINT(interpType, weight, duration, posX, posY, posZ, relativeTo) \
+    { CMD_BBH(interpType, weight, duration) }, { CMD_HH(posX, posY) }, { CMD_HH(posZ, relativeTo) }*/
+std::string CutsceneSubCommandEntry_SplineCamPoint::GetBodySourceCode() const
+{
+	return StringHelper::Sprintf("CS_CAM_POINT(0x%02X, 0x%02X, 0x%04X, 0x%04X, 0x%04X, 0x%04X, 0x%04X)", interpType, weight, duration, posX, posY, posZ, relTo);
+}
+
+size_t CutsceneSubCommandEntry_SplineCamPoint::GetRawSize() const
+{
+	return 0x0C;
+}
+
+
+CutsceneSubCommandEntry_SplineMiscPoint::CutsceneSubCommandEntry_SplineMiscPoint(const std::vector<uint8_t>& rawData,
+                                                               offset_t rawDataIndex): CutsceneSubCommandEntry(rawData, rawDataIndex)
+{
+	unused0 = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0);
+	roll = BitConverter::ToUInt16BE(rawData, rawDataIndex + 2);
+	fov = BitConverter::ToUInt16BE(rawData, rawDataIndex + 4);
+	unused1 = BitConverter::ToUInt16BE(rawData, rawDataIndex + 6);
+	printf("%s\n", GetBodySourceCode().c_str());
+}
+
+/*#define CS_CAM_MISC(unused0, roll, fov, unused1) \
+    { CMD_HH(unused0, roll) }, { CMD_HH(fov, unused1) }*/
+
+std::string CutsceneSubCommandEntry_SplineMiscPoint::GetBodySourceCode() const
+{
+	return StringHelper::Sprintf("CS_CAM_MISC(0x%04X, 0x%04X, 0x%04X, 0x%04X)", unused0, roll, fov, unused1);
+}
+
+size_t CutsceneSubCommandEntry_SplineMiscPoint::GetRawSize() const
+{
+	return 0x08;
+}
+
+CutsceneSubCommandEntry_SplineHeader::CutsceneSubCommandEntry_SplineHeader(const std::vector<uint8_t>& rawData,
+                                                               offset_t rawDataIndex): CutsceneSubCommandEntry(rawData, rawDataIndex)
+{
+	numEntries = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0);
+	unused0 = BitConverter::ToUInt16BE(rawData, rawDataIndex + 2);
+	unused1 = BitConverter::ToUInt16BE(rawData, rawDataIndex + 4);
+	duration = BitConverter::ToUInt16BE(rawData, rawDataIndex + 6);
+}
+
+std::string CutsceneSubCommandEntry_SplineHeader::GetBodySourceCode() const
 {
+	return StringHelper::Sprintf("CS_CAM_SPLINE(0x%04X, 0x%04X, 0x%04X, 0x%04X)", numEntries, unused0, unused1, duration);
+	
 }
 
-std::string CutsceneSubCommandEntry_Camera::GetBodySourceCode() const
+size_t CutsceneSubCommandEntry_SplineHeader::GetRawSize() const
 {
-	return StringHelper::Sprintf("CMD_HH(0x%04X, 0x%04X)", base, startFrame);
+	return 0x08;
 }
 
-size_t CutsceneSubCommandEntry_Camera::GetRawSize() const
+CutsceneSubCommandEntry_SplineFooter::CutsceneSubCommandEntry_SplineFooter(const std::vector<uint8_t>& rawData,
+                                                               offset_t rawDataIndex): CutsceneSubCommandEntry(rawData, rawDataIndex)
+{
+	uint16_t firstHalfWord = BitConverter::ToUInt16BE(rawData, rawDataIndex);
+	uint16_t secondHalfWord = BitConverter::ToUInt16BE(rawData, rawDataIndex + 2);
+
+	if (firstHalfWord != 0xFFFF || secondHalfWord != 4) {
+		HANDLE_ERROR(WarningType::InvalidExtractedData, "Invalid Spline Footer",
+		             StringHelper::Sprintf("Invalid Spline footer. Was expecting 0xFFFF, 0x0004. Got 0x%04X, 0x%04X",
+		             firstHalfWord, secondHalfWord));
+	}
+}
+/*#define CS_CAM_END() */
+std::string CutsceneSubCommandEntry_SplineFooter::GetBodySourceCode() const
+{
+	return "CS_CAM_END()";
+}
+
+size_t CutsceneSubCommandEntry_SplineFooter::GetRawSize() const
 {
 	return 0x04;
 }
 
-CutsceneMMCommand_Camera::CutsceneMMCommand_Camera(const std::vector<uint8_t>& rawData,
+CutsceneMMCommand_Spline::CutsceneMMCommand_Spline(const std::vector<uint8_t>& rawData,
                                                    offset_t rawDataIndex)
 	: CutsceneCommand(rawData, rawDataIndex)
 {
+	numHeaders = 0;
+	totalCommands = 0;
 	rawDataIndex += 4;
 
-	entries.reserve(numEntries);
-	for (size_t i = 0; i < numEntries / 4; i++)
-	{
-		auto* entry = new CutsceneSubCommandEntry_Camera(rawData, rawDataIndex);
-		entries.push_back(entry);
-		rawDataIndex += entry->GetRawSize();
+	while(1) {
+		if (BitConverter::ToUInt16BE(rawData, rawDataIndex) == 0xFFFF) {
+			break;
+		}
+		numHeaders++;
+
+		auto* header = new CutsceneSubCommandEntry_SplineHeader(rawData, rawDataIndex);
+		rawDataIndex += header->GetRawSize();
+		entries.push_back(header);
+			
+		totalCommands += header->numEntries;
+
+		for (uint32_t i = 0; i < header->numEntries; i++)
+		{
+			auto* entry = new CutsceneSubCommandEntry_SplineCamPoint(rawData, rawDataIndex);
+			entries.push_back(entry);
+			rawDataIndex += entry->GetRawSize();
+		}
+
+		for (uint32_t i = 0; i < header->numEntries; i++)
+		{
+			auto* entry = new CutsceneSubCommandEntry_SplineCamPoint(rawData, rawDataIndex);
+			entries.push_back(entry);
+			rawDataIndex += entry->GetRawSize();
+		}
+
+		for (uint32_t i = 0; i < header->numEntries; i++)
+		{
+			auto* entry = new CutsceneSubCommandEntry_SplineMiscPoint(rawData, rawDataIndex);
+			entries.push_back(entry);
+			rawDataIndex += entry->GetRawSize();
+		}
 	}
+
+	auto* footer = new CutsceneSubCommandEntry_SplineFooter(rawData, rawDataIndex);
+	entries.push_back(footer);
+	rawDataIndex += footer->GetRawSize();
 }
 
-std::string CutsceneMMCommand_Camera::GetCommandMacro() const
+std::string CutsceneMMCommand_Spline::GetCommandMacro() const
 {
 	return StringHelper::Sprintf("CS_CAM_SPLINE_LIST(%i)", numEntries);
 }
 
+size_t CutsceneMMCommand_Spline::GetCommandSize() const
+{
+	// 8 Bytes once for the spline command, 8 Bytes per spline the header, two grops of size 12, 1 group of size 8, 4 bytes for the footer.
+	return 8 + (8 * numHeaders) + ((totalCommands * 2) * 0xC) + (totalCommands * 8) + 4;
+}
+
+
 /**** TRANSITION GENERAL ****/
 
 CutsceneSubCommandEntry_TransitionGeneral::CutsceneSubCommandEntry_TransitionGeneral(
diff --git a/ZAPD/OtherStructs/CutsceneMM_Commands.h b/ZAPD/OtherStructs/CutsceneMM_Commands.h
index fb2f772..9891a24 100644
--- a/ZAPD/OtherStructs/CutsceneMM_Commands.h
+++ b/ZAPD/OtherStructs/CutsceneMM_Commands.h
@@ -268,24 +268,75 @@ public:
 
 // TODO: MM cutscene camera command is implemented as a placeholder until we better understand how
 // it works
-class CutsceneSubCommandEntry_Camera : public CutsceneSubCommandEntry
+
+class CutsceneSubCommandEntry_SplineCamPoint : public CutsceneSubCommandEntry
 {
 public:
-	uint32_t unk_08;
+	uint8_t interpType;
+	uint8_t weight;
+	uint16_t duration;
+
+	uint16_t posX;
+	uint16_t posY;
+
+	uint16_t posZ;
+	uint16_t relTo;
+
+	CutsceneSubCommandEntry_SplineCamPoint(const std::vector<uint8_t>& rawData, offset_t rawDataIndex);
+
+	std::string GetBodySourceCode() const override;
 
-	CutsceneSubCommandEntry_Camera(const std::vector<uint8_t>& rawData, offset_t rawDataIndex);
+	size_t GetRawSize() const override;
+};
+
+class CutsceneSubCommandEntry_SplineMiscPoint : public CutsceneSubCommandEntry
+{
+public:
+	uint16_t unused0;
+	uint16_t roll;
+	uint16_t fov;
+	uint16_t unused1;
+	
+	CutsceneSubCommandEntry_SplineMiscPoint(const std::vector<uint8_t>& rawData, offset_t rawDataIndex);
+
+	std::string GetBodySourceCode() const override;
+
+	size_t GetRawSize() const override;
+};
+
+class CutsceneSubCommandEntry_SplineFooter : public CutsceneSubCommandEntry
+{
+public:	
+	CutsceneSubCommandEntry_SplineFooter(const std::vector<uint8_t>& rawData, offset_t rawDataIndex);
+
+	std::string GetBodySourceCode() const override;
+
+	size_t GetRawSize() const override;
+};
+
+class CutsceneSubCommandEntry_SplineHeader : public CutsceneSubCommandEntry
+{
+public:
+	uint16_t numEntries;
+	uint16_t unused0;
+	uint16_t unused1;
+	uint16_t duration;
+	CutsceneSubCommandEntry_SplineHeader(const std::vector<uint8_t>& rawData, offset_t rawDataIndex);
 
 	std::string GetBodySourceCode() const override;
 
 	size_t GetRawSize() const override;
 };
 
-class CutsceneMMCommand_Camera : public CutsceneCommand
+class CutsceneMMCommand_Spline : public CutsceneCommand
 {
 public:
-	CutsceneMMCommand_Camera(const std::vector<uint8_t>& rawData, offset_t rawDataIndex);
+	uint32_t numHeaders;
+	uint32_t totalCommands;
+	CutsceneMMCommand_Spline(const std::vector<uint8_t>& rawData, offset_t rawDataIndex);
 
 	std::string GetCommandMacro() const override;
+	size_t GetCommandSize() const override;
 };
 
 /**** TRANSITION GENERAL ****/