first commit

ZAPDTR/ZAPD/ZRoom/Commands/EndMarker.cpp

@@ -0,0 +1,20 @@
+#include "EndMarker.h"
+
+EndMarker::EndMarker(ZFile* nParent) : ZRoomCommand(nParent)
+{
+}
+
+std::string EndMarker::GetBodySourceCode() const
+{
+	return "SCENE_CMD_END()";
+}
+
+std::string EndMarker::GetCommandCName() const
+{
+	return "SCmdEndMarker";
+}
+
+RoomCommand EndMarker::GetRoomCommand() const
+{
+	return RoomCommand::EndMarker;
+}

ZAPDTR/ZAPD/ZRoom/Commands/EndMarker.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include "ZRoom/ZRoomCommand.h"
+
+class EndMarker : public ZRoomCommand
+{
+public:
+	EndMarker(ZFile* nParent);
+
+	std::string GetBodySourceCode() const override;
+	std::string GetCommandCName() const override;
+	RoomCommand GetRoomCommand() const override;
+};

ZAPDTR/ZAPD/ZRoom/Commands/SetActorCutsceneList.cpp

@@ -0,0 +1,95 @@
+#include "SetActorCutsceneList.h"
+
+#include "Globals.h"
+#include "Utils/BitConverter.h"
+#include "Utils/StringHelper.h"
+#include "ZFile.h"
+#include "ZRoom/ZRoom.h"
+
+SetActorCutsceneList::SetActorCutsceneList(ZFile* nParent) : ZRoomCommand(nParent)
+{
+}
+
+void SetActorCutsceneList::ParseRawData()
+{
+	ZRoomCommand::ParseRawData();
+	int numCutscenes = cmdArg1;
+	offset_t currentPtr = segmentOffset;
+
+	cutscenes.reserve(numCutscenes);
+	for (int32_t i = 0; i < numCutscenes; i++)
+	{
+		ActorCutsceneEntry entry(parent->GetRawData(), currentPtr);
+		cutscenes.push_back(entry);
+
+		currentPtr += 16;
+	}
+}
+
+void SetActorCutsceneList::DeclareReferences(const std::string& prefix)
+{
+	if (cutscenes.size() > 0)
+	{
+		std::string declaration;
+
+		for (size_t i = 0; i < cutscenes.size(); i++)
+		{
+			const auto& entry = cutscenes.at(i);
+			declaration += StringHelper::Sprintf("    { %s },", entry.GetBodySourceCode().c_str());
+
+			if (i + 1 < cutscenes.size())
+			{
+				declaration += "\n";
+			}
+		}
+
+		std::string typeName = cutscenes.at(0).GetSourceTypeName();
+
+		parent->AddDeclarationArray(
+			segmentOffset, GetDeclarationAlignment(), cutscenes.size() * 16, typeName,
+			StringHelper::Sprintf("%s%sList_%06X", prefix.c_str(), typeName.c_str(), segmentOffset),
+			cutscenes.size(), declaration);
+	}
+}
+
+std::string SetActorCutsceneList::GetBodySourceCode() const
+{
+	std::string listName;
+	Globals::Instance->GetSegmentedPtrName(cmdArg2, parent, "ActorCutscene", listName,
+	                                       parent->workerID);
+	return StringHelper::Sprintf("SCENE_CMD_ACTOR_CUTSCENE_LIST(%i, %s)", cutscenes.size(),
+	                             listName.c_str());
+}
+
+std::string SetActorCutsceneList::GetCommandCName() const
+{
+	return "SCmdCutsceneActorList";
+}
+
+RoomCommand SetActorCutsceneList::GetRoomCommand() const
+{
+	return RoomCommand::SetActorCutsceneList;
+}
+
+ActorCutsceneEntry::ActorCutsceneEntry(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex)
+	: priority(BitConverter::ToInt16BE(rawData, rawDataIndex + 0)),
+	  length(BitConverter::ToInt16BE(rawData, rawDataIndex + 2)),
+	  unk4(BitConverter::ToInt16BE(rawData, rawDataIndex + 4)),
+	  unk6(BitConverter::ToInt16BE(rawData, rawDataIndex + 6)),
+	  additionalCutscene(BitConverter::ToInt16BE(rawData, rawDataIndex + 8)),
+	  sound(rawData[rawDataIndex + 0xA]), unkB(rawData[rawDataIndex + 0xB]),
+	  unkC(BitConverter::ToInt16BE(rawData, rawDataIndex + 0xC)), unkE(rawData[rawDataIndex + 0xE]),
+	  letterboxSize(rawData[rawDataIndex + 0xF])
+{
+}
+
+std::string ActorCutsceneEntry::GetBodySourceCode() const
+{
+	return StringHelper::Sprintf("%i, %i, %i, %i, %i, %i, %i, %i, %i, %i", priority, length, unk4,
+	                             unk6, additionalCutscene, sound, unkB, unkC, unkE, letterboxSize);
+}
+
+std::string ActorCutsceneEntry::GetSourceTypeName() const
+{
+	return "ActorCutscene";
+}

ZAPDTR/ZAPD/ZRoom/Commands/SetActorCutsceneList.h

@@ -0,0 +1,42 @@
+#pragma once
+
+#include "ZRoom/ZRoomCommand.h"
+
+class ActorCutsceneEntry
+{
+protected:
+	int16_t priority;
+	int16_t length;
+	int16_t unk4;
+	int16_t unk6;
+	int16_t additionalCutscene;
+	uint8_t sound;
+	uint8_t unkB;
+	int16_t unkC;
+	uint8_t unkE;
+	uint8_t letterboxSize;
+
+public:
+	ActorCutsceneEntry(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex);
+
+	std::string GetBodySourceCode() const;
+	std::string GetSourceTypeName() const;
+};
+
+class SetActorCutsceneList : public ZRoomCommand
+{
+public:
+	std::vector<ActorCutsceneEntry> cutscenes;
+
+	SetActorCutsceneList(ZFile* nParent);
+
+	void ParseRawData() override;
+	void DeclareReferences(const std::string& prefix) override;
+
+	std::string GetBodySourceCode() const override;
+
+	std::string GetCommandCName() const override;
+	RoomCommand GetRoomCommand() const override;
+
+private:
+};

ZAPDTR/ZAPD/ZRoom/Commands/SetActorList.cpp

@@ -0,0 +1,59 @@
+#include "SetActorList.h"
+
+#include <cassert>
+
+#include "Globals.h"
+#include "Utils/BitConverter.h"
+#include "Utils/StringHelper.h"
+#include "ZRoom/ZRoom.h"
+
+SetActorList::SetActorList(ZFile* nParent) : ZRoomCommand(nParent)
+{
+}
+
+void SetActorList::ParseRawData()
+{
+	ZRoomCommand::ParseRawData();
+	numActors = cmdArg1;
+
+	actorList = new ZActorList(parent);
+	actorList->ExtractFromBinary(segmentOffset, numActors);
+}
+
+void SetActorList::DeclareReferences(const std::string& prefix)
+{
+	if (parent->HasDeclaration(segmentOffset))
+	{
+		delete actorList;
+		actorList = static_cast<ZActorList*>(parent->FindResource(segmentOffset));
+		assert(actorList != nullptr);
+		assert(actorList->GetResourceType() == ZResourceType::ActorList);
+		return;
+	}
+
+	if (actorList->GetName() == "")
+	{
+		actorList->SetName(actorList->GetDefaultName(prefix));
+	}
+	actorList->DeclareVar(prefix, "");
+	parent->AddResource(actorList);
+}
+
+std::string SetActorList::GetBodySourceCode() const
+{
+	std::string listName;
+	Globals::Instance->GetSegmentedPtrName(cmdArg2, parent, "ActorEntry", listName,
+	                                       parent->workerID);
+
+	return StringHelper::Sprintf("SCENE_CMD_ACTOR_LIST(%i, %s)", numActors, listName.c_str());
+}
+
+std::string SetActorList::GetCommandCName() const
+{
+	return "SCmdActorList";
+}
+
+RoomCommand SetActorList::GetRoomCommand() const
+{
+	return RoomCommand::SetActorList;
+}

ZAPDTR/ZAPD/ZRoom/Commands/SetActorList.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include "ZActorList.h"
+#include "ZRoom/ZRoomCommand.h"
+
+class SetActorList : public ZRoomCommand
+{
+public:
+	uint32_t numActors;
+	ZActorList* actorList = nullptr;
+
+	SetActorList(ZFile* nParent);
+
+	void ParseRawData() override;
+	void DeclareReferences(const std::string& prefix) override;
+
+	std::string GetBodySourceCode() const override;
+
+	RoomCommand GetRoomCommand() const override;
+	std::string GetCommandCName() const override;
+
+protected:
+	size_t GetActorListArraySize() const;
+};

ZAPDTR/ZAPD/ZRoom/Commands/SetAlternateHeaders.cpp

@@ -0,0 +1,84 @@
+#include "SetAlternateHeaders.h"
+
+#include "Globals.h"
+#include "Utils/BitConverter.h"
+#include "Utils/StringHelper.h"
+#include "ZFile.h"
+
+SetAlternateHeaders::SetAlternateHeaders(ZFile* nParent) : ZRoomCommand(nParent)
+{
+}
+
+void SetAlternateHeaders::DeclareReferences([[maybe_unused]] const std::string& prefix)
+{
+	if (cmdArg2 != 0)
+	{
+		std::string varName =
+			StringHelper::Sprintf("%sAlternateHeaders0x%06X", prefix.c_str(), segmentOffset);
+		parent->AddDeclarationPlaceholder(segmentOffset, varName);
+	}
+}
+
+void SetAlternateHeaders::ParseRawDataLate()
+{
+	size_t numHeaders = zRoom->GetDeclarationSizeFromNeighbor(segmentOffset) / 4;
+
+	headers.reserve(numHeaders);
+	for (uint32_t i = 0; i < numHeaders; i++)
+	{
+		int32_t address = BitConverter::ToInt32BE(parent->GetRawData(), segmentOffset + (i * 4));
+		headers.push_back(address);
+
+		if (address != 0 && parent->GetDeclaration(GETSEGOFFSET(address)) == nullptr)
+		{
+			ZRoom* altheader = new ZRoom(parent);
+			altheader->ExtractFromBinary(GETSEGOFFSET(address), zRoom->GetResourceType());
+			altheader->DeclareReferences(parent->GetName());
+
+			parent->resources.push_back(altheader);
+		}
+	}
+}
+
+void SetAlternateHeaders::DeclareReferencesLate(const std::string& prefix)
+{
+	if (!headers.empty())
+	{
+		std::string declaration;
+
+		for (size_t i = 0; i < headers.size(); i++)
+		{
+			std::string altHeaderName;
+			Globals::Instance->GetSegmentedPtrName(headers.at(i), parent, "", altHeaderName,
+			                                       parent->workerID);
+
+			declaration += StringHelper::Sprintf("\t%s,", altHeaderName.c_str());
+
+			if (i + 1 < headers.size())
+				declaration += "\n";
+		}
+
+		std::string varName =
+			StringHelper::Sprintf("%sAlternateHeaders0x%06X", prefix.c_str(), segmentOffset);
+		parent->AddDeclarationArray(segmentOffset, GetDeclarationAlignment(), headers.size() * 4,
+		                            "SceneCmd*", varName, headers.size(), declaration);
+	}
+}
+
+std::string SetAlternateHeaders::GetBodySourceCode() const
+{
+	std::string listName;
+	Globals::Instance->GetSegmentedPtrName(cmdArg2, parent, "SceneCmd*", listName,
+	                                       parent->workerID);
+	return StringHelper::Sprintf("SCENE_CMD_ALTERNATE_HEADER_LIST(%s)", listName.c_str());
+}
+
+std::string SetAlternateHeaders::GetCommandCName() const
+{
+	return "SCmdAltHeaders";
+}
+
+RoomCommand SetAlternateHeaders::GetRoomCommand() const
+{
+	return RoomCommand::SetAlternateHeaders;
+}

ZAPDTR/ZAPD/ZRoom/Commands/SetAlternateHeaders.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include "ZRoom/ZRoom.h"
+#include "ZRoom/ZRoomCommand.h"
+
+class SetAlternateHeaders : public ZRoomCommand
+{
+public:
+	std::vector<uint32_t> headers;
+
+	SetAlternateHeaders(ZFile* nParent);
+
+	void DeclareReferences(const std::string& prefix) override;
+	void ParseRawDataLate() override;
+	void DeclareReferencesLate(const std::string& prefix) override;
+
+	std::string GetBodySourceCode() const override;
+
+	RoomCommand GetRoomCommand() const override;
+	std::string GetCommandCName() const override;
+
+private:
+};

ZAPDTR/ZAPD/ZRoom/Commands/SetAnimatedMaterialList.cpp

@@ -0,0 +1,49 @@
+/**
+ * File: SetAnimatedMaterialList.cpp
+ * Description: Defines a class SetAnimatedMaterialList to enable ZRoom to declare
+ * ZTextureAnimations, using that ZResource to do the work.
+ */
+#include "SetAnimatedMaterialList.h"
+
+#include "Globals.h"
+#include "Utils/BitConverter.h"
+#include "Utils/StringHelper.h"
+#include "ZFile.h"
+#include "ZRoom/ZRoom.h"
+#include "ZTextureAnimation.h"
+
+SetAnimatedMaterialList::SetAnimatedMaterialList(ZFile* nParent)
+	: ZRoomCommand(nParent), textureAnimation(nParent)
+{
+}
+
+void SetAnimatedMaterialList::ParseRawData()
+{
+	ZRoomCommand::ParseRawData();
+	textureAnimation.ExtractFromFile(segmentOffset);
+}
+
+void SetAnimatedMaterialList::DeclareReferences(const std::string& prefix)
+{
+	textureAnimation.SetName(textureAnimation.GetDefaultName(prefix.c_str()));
+	textureAnimation.DeclareReferences(prefix);
+	textureAnimation.GetSourceOutputCode(prefix);
+}
+
+std::string SetAnimatedMaterialList::GetBodySourceCode() const
+{
+	std::string listName;
+	Globals::Instance->GetSegmentedPtrName(cmdArg2, parent, "AnimatedMaterial", listName,
+	                                       parent->workerID);
+	return StringHelper::Sprintf("SCENE_CMD_ANIMATED_MATERIAL_LIST(%s)", listName.c_str());
+}
+
+std::string SetAnimatedMaterialList::GetCommandCName() const
+{
+	return "SCmdTextureAnimations";
+}
+
+RoomCommand SetAnimatedMaterialList::GetRoomCommand() const
+{
+	return RoomCommand::SetAnimatedMaterialList;
+}

ZAPDTR/ZAPD/ZRoom/Commands/SetAnimatedMaterialList.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "ZRoom/ZRoomCommand.h"
+#include "ZTextureAnimation.h"
+
+class SetAnimatedMaterialList : public ZRoomCommand
+{
+public:
+	SetAnimatedMaterialList(ZFile* nParent);
+
+	void ParseRawData() override;
+	void DeclareReferences(const std::string& prefix) override;
+
+	std::string GetBodySourceCode() const override;
+
+	RoomCommand GetRoomCommand() const override;
+	std::string GetCommandCName() const override;
+
+private:
+	ZTextureAnimation textureAnimation;
+};

ZAPDTR/ZAPD/ZRoom/Commands/SetCameraSettings.cpp

@@ -0,0 +1,31 @@
+#include "SetCameraSettings.h"
+
+#include "Utils/BitConverter.h"
+#include "Utils/StringHelper.h"
+
+SetCameraSettings::SetCameraSettings(ZFile* nParent) : ZRoomCommand(nParent)
+{
+}
+
+void SetCameraSettings::ParseRawData()
+{
+	ZRoomCommand::ParseRawData();
+	cameraMovement = cmdArg1;
+	mapHighlight = BitConverter::ToUInt32BE(parent->GetRawData(), rawDataIndex + 4);
+}
+
+std::string SetCameraSettings::GetBodySourceCode() const
+{
+	return StringHelper::Sprintf("SCENE_CMD_MISC_SETTINGS(0x%02X, 0x%08X)", cameraMovement,
+	                             mapHighlight);
+}
+
+std::string SetCameraSettings::GetCommandCName() const
+{
+	return "SCmdMiscSettings";
+}
+
+RoomCommand SetCameraSettings::GetRoomCommand() const
+{
+	return RoomCommand::SetCameraSettings;
+}

ZAPDTR/ZAPD/ZRoom/Commands/SetCameraSettings.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "ZRoom/ZRoomCommand.h"
+
+class SetCameraSettings : public ZRoomCommand
+{
+public:
+	uint8_t cameraMovement;
+	uint32_t mapHighlight;
+
+	SetCameraSettings(ZFile* nParent);
+
+	void ParseRawData() override;
+
+	std::string GetBodySourceCode() const override;
+
+	std::string GetCommandCName() const override;
+	RoomCommand GetRoomCommand() const override;
+
+private:
+};

ZAPDTR/ZAPD/ZRoom/Commands/SetCollisionHeader.cpp

@@ -0,0 +1,45 @@
+#include "SetCollisionHeader.h"
+
+#include "Globals.h"
+#include "Utils/BitConverter.h"
+#include "Utils/StringHelper.h"
+#include "ZFile.h"
+#include "ZRoom/ZRoom.h"
+
+SetCollisionHeader::SetCollisionHeader(ZFile* nParent) : ZRoomCommand(nParent)
+{
+}
+
+void SetCollisionHeader::ParseRawData()
+{
+	ZRoomCommand::ParseRawData();
+
+	collisionHeader = new ZCollisionHeader(parent);
+	collisionHeader->SetName(
+		StringHelper::Sprintf("%sCollisionHeader_%06X", parent->GetName().c_str(), segmentOffset));
+	collisionHeader->ExtractFromFile(segmentOffset);
+	parent->AddResource(collisionHeader);
+}
+
+void SetCollisionHeader::DeclareReferences(const std::string& prefix)
+{
+	collisionHeader->DeclareVar(prefix, "");
+}
+
+std::string SetCollisionHeader::GetBodySourceCode() const
+{
+	std::string listName;
+	Globals::Instance->GetSegmentedPtrName(cmdArg2, parent, "CollisionHeader", listName,
+	                                       parent->workerID);
+	return StringHelper::Sprintf("SCENE_CMD_COL_HEADER(%s)", listName.c_str());
+}
+
+std::string SetCollisionHeader::GetCommandCName() const
+{
+	return "SCmdColHeader";
+}
+
+RoomCommand SetCollisionHeader::GetRoomCommand() const
+{
+	return RoomCommand::SetCollisionHeader;
+}

ZAPDTR/ZAPD/ZRoom/Commands/SetCollisionHeader.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include "ZCollision.h"
+#include "ZRoom/ZRoomCommand.h"
+
+class SetCollisionHeader : public ZRoomCommand
+{
+public:
+	ZCollisionHeader* collisionHeader;
+
+	SetCollisionHeader(ZFile* nParent);
+
+	void ParseRawData() override;
+	void DeclareReferences(const std::string& prefix) override;
+
+	std::string GetBodySourceCode() const override;
+
+	std::string GetCommandCName() const override;
+	RoomCommand GetRoomCommand() const override;
+};

ZAPDTR/ZAPD/ZRoom/Commands/SetCsCamera.cpp

@@ -0,0 +1,155 @@
+#include "SetCsCamera.h"
+
+#include "Globals.h"
+#include "Utils/BitConverter.h"
+#include "Utils/StringHelper.h"
+#include "ZFile.h"
+#include "ZRoom/ZRoom.h"
+
+SetCsCamera::SetCsCamera(ZFile* nParent) : ZRoomCommand(nParent)
+{
+}
+
+void SetCsCamera::ParseRawData()
+{
+	ZRoomCommand::ParseRawData();
+	int numCameras = cmdArg1;
+
+	uint32_t currentPtr = segmentOffset;
+	int32_t numPoints = 0;
+
+	cameras.reserve(numCameras);
+	for (int32_t i = 0; i < numCameras; i++)
+	{
+		CsCameraEntry entry(parent->GetRawData(), currentPtr);
+		numPoints += entry.GetNumPoints();
+
+		currentPtr += entry.GetRawDataSize();
+		cameras.push_back(entry);
+	}
+
+	if (numPoints > 0)
+	{
+		uint32_t currentPtr = cameras.at(0).GetSegmentOffset();
+
+		points.reserve(numPoints);
+		for (int32_t i = 0; i < numPoints; i++)
+		{
+			ZVector vec(parent);
+			vec.ExtractFromBinary(currentPtr, ZScalarType::ZSCALAR_S16, 3);
+
+			currentPtr += vec.GetRawDataSize();
+			points.push_back(vec);
+		}
+	}
+}
+
+void SetCsCamera::DeclareReferences(const std::string& prefix)
+{
+	if (points.size() > 0)
+	{
+		std::string declaration;
+		size_t index = 0;
+		for (auto& point : points)
+		{
+			declaration += StringHelper::Sprintf("\t{ %s },", point.GetBodySourceCode().c_str());
+
+			if (index < points.size() - 1)
+				declaration += "\n";
+
+			index++;
+		}
+
+		uint32_t segOffset = cameras.at(0).GetSegmentOffset();
+
+		parent->AddDeclarationArray(
+			segOffset, DeclarationAlignment::Align4, points.size() * points.at(0).GetRawDataSize(),
+			points.at(0).GetSourceTypeName().c_str(),
+			StringHelper::Sprintf("%sCsCameraPoints_%06X", prefix.c_str(), segOffset),
+			points.size(), declaration);
+	}
+
+	if (!cameras.empty())
+	{
+		std::string camPointsName;
+		Globals::Instance->GetSegmentedPtrName(cameras.at(0).GetCamAddress(), parent, "Vec3s",
+		                                       camPointsName, parent->workerID);
+		std::string declaration;
+
+		size_t index = 0;
+		size_t pointsIndex = 0;
+		for (const auto& entry : cameras)
+		{
+			declaration +=
+				StringHelper::Sprintf("\t{ %i, %i, &%s[%i] },", entry.type, entry.numPoints,
+			                          camPointsName.c_str(), pointsIndex);
+
+			if (index < cameras.size() - 1)
+				declaration += "\n";
+
+			index++;
+			pointsIndex += entry.GetNumPoints();
+		}
+
+		const auto& entry = cameras.front();
+		std::string camTypename = entry.GetSourceTypeName();
+
+		parent->AddDeclarationArray(
+			segmentOffset, DeclarationAlignment::Align4, cameras.size() * entry.GetRawDataSize(),
+			camTypename,
+			StringHelper::Sprintf("%s%s_%06X", prefix.c_str(), camTypename.c_str(), segmentOffset),
+			cameras.size(), declaration);
+	}
+}
+
+std::string SetCsCamera::GetBodySourceCode() const
+{
+	std::string listName;
+	Globals::Instance->GetSegmentedPtrName(cmdArg2, parent, "CsCameraEntry", listName,
+	                                       parent->workerID);
+	return StringHelper::Sprintf("SCENE_CMD_ACTOR_CUTSCENE_CAM_LIST(%i, %s)", cameras.size(),
+	                             listName.c_str());
+}
+
+std::string SetCsCamera::GetCommandCName() const
+{
+	return "SCmdCsCameraList";
+}
+
+RoomCommand SetCsCamera::GetRoomCommand() const
+{
+	return RoomCommand::SetCsCamera;
+}
+
+CsCameraEntry::CsCameraEntry(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex)
+	: baseOffset(rawDataIndex), type(BitConverter::ToInt16BE(rawData, rawDataIndex + 0)),
+	  numPoints(BitConverter::ToInt16BE(rawData, rawDataIndex + 2))
+{
+	camAddress = BitConverter::ToInt32BE(rawData, rawDataIndex + 4);
+	segmentOffset = GETSEGOFFSET(camAddress);
+}
+
+std::string CsCameraEntry::GetSourceTypeName() const
+{
+	return "CsCameraEntry";
+}
+
+int32_t CsCameraEntry::GetRawDataSize() const
+{
+	return 8;
+}
+
+int16_t CsCameraEntry::GetNumPoints() const
+{
+	return numPoints;
+}
+
+segptr_t CsCameraEntry::GetCamAddress() const
+{
+	return camAddress;
+}
+
+uint32_t CsCameraEntry::GetSegmentOffset() const
+{
+	return segmentOffset;
+}

ZAPDTR/ZAPD/ZRoom/Commands/SetCsCamera.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include "ZRoom/ZRoomCommand.h"
+#include "ZVector.h"
+
+class CsCameraEntry
+{
+public:
+	CsCameraEntry(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex);
+
+	std::string GetSourceTypeName() const;
+	int32_t GetRawDataSize() const;
+
+	int16_t GetNumPoints() const;
+	segptr_t GetCamAddress() const;
+	uint32_t GetSegmentOffset() const;
+
+	int baseOffset;
+	int16_t type;
+	int16_t numPoints;
+	segptr_t camAddress;
+	uint32_t segmentOffset;
+};
+
+class SetCsCamera : public ZRoomCommand
+{
+public:
+	std::vector<CsCameraEntry> cameras;
+	std::vector<ZVector> points;
+
+	SetCsCamera(ZFile* nParent);
+
+	void ParseRawData() override;
+	void DeclareReferences(const std::string& prefix) override;
+
+	std::string GetBodySourceCode() const override;
+
+	RoomCommand GetRoomCommand() const override;
+	std::string GetCommandCName() const override;
+};

ZAPDTR/ZAPD/ZRoom/Commands/SetCutsceneEntryList.cpp

@@ -0,0 +1,103 @@
+#include "SetCutsceneEntryList.h"
+
+#include "Globals.h"
+#include "Utils/BitConverter.h"
+#include "Utils/StringHelper.h"
+#include "ZFile.h"
+#include "ZRoom/ZRoom.h"
+
+SetActorCutsceneList::SetActorCutsceneList(ZFile* nParent) : ZRoomCommand(nParent)
+{
+}
+
+void SetActorCutsceneList::ParseRawData()
+{
+	ZRoomCommand::ParseRawData();
+	int numCutscenes = cmdArg1;
+	offset_t currentPtr = segmentOffset;
+
+	cutscenes.reserve(numCutscenes);
+	for (int32_t i = 0; i < numCutscenes; i++)
+	{
+		CutsceneEntry entry(parent->GetRawData(), currentPtr);
+		cutscenes.push_back(entry);
+
+		currentPtr += 16;
+	}
+}
+
+void SetActorCutsceneList::DeclareReferences(const std::string& prefix)
+{
+	if (cutscenes.size() > 0)
+	{
+		std::string declaration;
+
+		for (size_t i = 0; i < cutscenes.size(); i++)
+		{
+			const auto& entry = cutscenes.at(i);
+			declaration += StringHelper::Sprintf("    { %s },", entry.GetBodySourceCode().c_str());
+
+			if (i + 1 < cutscenes.size())
+			{
+				declaration += "\n";
+			}
+		}
+
+		std::string typeName = cutscenes.at(0).GetSourceTypeName();
+
+		parent->AddDeclarationArray(
+			segmentOffset, GetDeclarationAlignment(), cutscenes.size() * 16, typeName,
+			StringHelper::Sprintf("%s%sList_%06X", prefix.c_str(), typeName.c_str(), segmentOffset),
+			cutscenes.size(), declaration);
+	}
+}
+
+std::string SetActorCutsceneList::GetBodySourceCode() const
+{
+	std::string listName;
+	Globals::Instance->GetSegmentedPtrName(cmdArg2, parent, "CutsceneEntry", listName, parent->workerID);
+	return StringHelper::Sprintf("SCENE_CMD_ACTOR_CUTSCENE_LIST(%i, %s)", cutscenes.size(),
+	                             listName.c_str());
+}
+
+std::string SetActorCutsceneList::GetCommandCName() const
+{
+	return "SCmdCutsceneActorList";
+}
+
+RoomCommand SetActorCutsceneList::GetRoomCommand() const
+{
+	return RoomCommand::SetActorCutsceneList;
+}
+
+CutsceneEntry::CutsceneEntry(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex)
+	: priority(BitConverter::ToInt16BE(rawData, rawDataIndex + 0)),
+	  length(BitConverter::ToInt16BE(rawData, rawDataIndex + 2)),
+	  csCamId(BitConverter::ToInt16BE(rawData, rawDataIndex + 4)),
+	  scriptIndex(BitConverter::ToInt16BE(rawData, rawDataIndex + 6)),
+	  additionalCsId(BitConverter::ToInt16BE(rawData, rawDataIndex + 8)),
+	  endSfx(rawData[rawDataIndex + 0xA]), customValue(rawData[rawDataIndex + 0xB]),
+	  hudVisibility(BitConverter::ToInt16BE(rawData, rawDataIndex + 0xC)),
+	  endCam(rawData[rawDataIndex + 0xE]), letterboxSize(rawData[rawDataIndex + 0xF])
+{
+}
+
+std::string CutsceneEntry::GetBodySourceCode() const
+{
+	EnumData* enumData = &Globals::Instance->cfg.enumData;
+
+	if (enumData->endSfx.find(endSfx) != enumData->endSfx.end())
+		return StringHelper::Sprintf("%i, %i, %i, %i, %i, %s, %i, %i, %i, %i", priority, length,
+		                             csCamId, scriptIndex, additionalCsId,
+		                             enumData->endSfx[endSfx].c_str(), customValue, hudVisibility,
+		                             endCam, letterboxSize);
+	else
+		return StringHelper::Sprintf("%i, %i, %i, %i, %i, %i, %i, %i, %i, %i", priority, length,
+		                             csCamId, scriptIndex, additionalCsId, endSfx, customValue,
+		                             hudVisibility, endCam, letterboxSize);
+}
+
+std::string CutsceneEntry::GetSourceTypeName() const
+{
+	return "CutsceneEntry";
+}

ZAPDTR/ZAPD/ZRoom/Commands/SetCutsceneEntryList.h

@@ -0,0 +1,42 @@
+#pragma once
+
+#include "ZRoom/ZRoomCommand.h"
+
+class CutsceneEntry
+{
+public:
+	int16_t priority;
+	int16_t length;
+	int16_t csCamId;
+	int16_t scriptIndex;
+	int16_t additionalCsId;
+	uint8_t endSfx;
+	uint8_t customValue;
+	int16_t hudVisibility;
+	uint8_t endCam;
+	uint8_t letterboxSize;
+
+
+	CutsceneEntry(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex);
+
+	std::string GetBodySourceCode() const;
+	std::string GetSourceTypeName() const;
+};
+
+class SetActorCutsceneList : public ZRoomCommand
+{
+public:
+	std::vector<CutsceneEntry> cutscenes;
+
+	SetActorCutsceneList(ZFile* nParent);
+
+	void ParseRawData() override;
+	void DeclareReferences(const std::string& prefix) override;
+
+	std::string GetBodySourceCode() const override;
+
+	std::string GetCommandCName() const override;
+	RoomCommand GetRoomCommand() const override;
+
+private:
+};

ZAPDTR/ZAPD/ZRoom/Commands/SetCutscenes.cpp

@@ -0,0 +1,146 @@
+#include "SetCutscenes.h"
+
+#include "Globals.h"
+#include "Utils/BitConverter.h"
+#include "Utils/StringHelper.h"
+#include "ZFile.h"
+#include "ZRoom/ZRoom.h"
+
+SetCutscenes::SetCutscenes(ZFile* nParent) : ZRoomCommand(nParent)
+{
+}
+
+void SetCutscenes::ParseRawData()
+{
+	ZRoomCommand::ParseRawData();
+
+	numCutscenes = cmdArg1;
+
+	if (Globals::Instance->game == ZGame::MM_RETAIL)
+	{
+		int32_t currentPtr = segmentOffset;
+
+		cutsceneEntries.reserve(numCutscenes);
+		for (uint8_t i = 0; i < numCutscenes; i++)
+		{
+			CutsceneEntry entry(parent->GetRawData(), currentPtr);
+			cutsceneEntries.push_back(entry);
+			currentPtr += 8;
+		}
+	} 
+	else if (Globals::Instance->game == ZGame::OOT_RETAIL || Globals::Instance->game == ZGame::OOT_SW97)
+	{
+		ZCutscene* cutscene = new ZCutscene(parent);
+		cutscene->ExtractFromFile(segmentOffset);
+
+		auto decl = parent->GetDeclaration(segmentOffset);
+		if (decl == nullptr)
+		{
+			cutscene->DeclareVar(zRoom->GetName().c_str(), "");
+		}
+
+		cutscenes.push_back(cutscene);
+	}
+}
+
+void SetCutscenes::DeclareReferences(const std::string& prefix)
+{
+	std::string varPrefix = name;
+	if (varPrefix == "")
+		varPrefix = prefix;
+
+	if (Globals::Instance->game == ZGame::MM_RETAIL)
+	{
+		std::string declaration;
+		size_t i = 0;
+
+		for (const auto& entry : cutsceneEntries)
+		{
+			if (entry.segmentPtr != SEGMENTED_NULL &&
+			    GETSEGNUM(entry.segmentPtr) == parent->segment)
+			{
+				offset_t csOffset = Seg2Filespace(entry.segmentPtr, parent->baseAddress);
+				if (!parent->HasDeclaration(csOffset))
+				{
+					auto* cutscene = new ZCutscene(parent);
+					cutscene->ExtractFromFile(csOffset);
+					cutscene->SetName(cutscene->GetDefaultName(varPrefix));
+					cutscene->DeclareVar(varPrefix, "");
+					cutscene->DeclareReferences(varPrefix);
+					parent->AddResource(cutscene);
+				}
+			}
+
+			std::string csName;
+			Globals::Instance->GetSegmentedPtrName(entry.segmentPtr, parent, "CutsceneData",
+			                                       csName, parent->workerID);
+
+			declaration +=
+				StringHelper::Sprintf("    { %s, 0x%04X, 0x%02X, 0x%02X },", csName.c_str(),
+			                          entry.exit, entry.entrance, entry.flag);
+
+			if (i + 1 < numCutscenes)
+				declaration += "\n";
+
+			i++;
+		}
+
+		parent->AddDeclarationArray(segmentOffset, DeclarationAlignment::Align4,
+		                            cutsceneEntries.size() * 8, "CutsceneEntry",
+		                            StringHelper::Sprintf("%sCutsceneEntryList_%06X",
+		                                                  zRoom->GetName().c_str(), segmentOffset),
+		                            cutsceneEntries.size(), declaration);
+	}
+	else
+	{
+		if (cmdArg2 != SEGMENTED_NULL && GETSEGNUM(cmdArg2) == parent->segment)
+		{
+			offset_t csOffset = Seg2Filespace(cmdArg2, parent->baseAddress);
+			if (!parent->HasDeclaration(csOffset))
+			{
+				auto* cutscene = new ZCutscene(parent);
+				cutscene->ExtractFromFile(csOffset);
+				cutscene->SetName(cutscene->GetDefaultName(varPrefix));
+				cutscene->DeclareVar(varPrefix, "");
+				cutscene->DeclareReferences(varPrefix);
+				parent->AddResource(cutscene);
+			}
+		}
+	}
+}
+
+std::string SetCutscenes::GetBodySourceCode() const
+{
+	std::string listName;
+	Globals::Instance->GetSegmentedPtrName(cmdArg2, parent, "CutsceneData", listName,
+	                                       parent->workerID);
+
+	if (Globals::Instance->game == ZGame::MM_RETAIL)
+	{
+		Globals::Instance->GetSegmentedPtrName(cmdArg2, parent, "CutsceneEntry", listName,
+		                                       parent->workerID);
+		return StringHelper::Sprintf("SCENE_CMD_CUTSCENE_LIST(%i, %s)", numCutscenes,
+		                             listName.c_str());
+	}
+
+	Globals::Instance->GetSegmentedPtrName(cmdArg2, parent, "CutsceneData", listName,
+	                                       parent->workerID);
+	return StringHelper::Sprintf("SCENE_CMD_CUTSCENE_DATA(%s)", listName.c_str());
+}
+
+std::string SetCutscenes::GetCommandCName() const
+{
+	return "SCmdCutsceneData";
+}
+
+RoomCommand SetCutscenes::GetRoomCommand() const
+{
+	return RoomCommand::SetCutscenes;
+}
+
+CutsceneEntry::CutsceneEntry(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex)
+	: segmentPtr(BitConverter::ToInt32BE(rawData, rawDataIndex + 0)),
+	  exit(BitConverter::ToInt16BE(rawData, rawDataIndex + 4)), entrance(rawData[rawDataIndex + 6]),
+	  flag(rawData[rawDataIndex + 7])
+{
+}

ZAPDTR/ZAPD/ZRoom/Commands/SetCutscenes.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include "ZCutscene.h"
+#include "ZRoom/ZRoomCommand.h"
+
+class CutsceneEntry
+{
+public:
+	CutsceneEntry(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex);
+
+	segptr_t segmentPtr;
+	uint16_t exit;
+	uint8_t entrance;
+	uint8_t flag;
+};
+
+class SetCutscenes : public ZRoomCommand
+{
+public:
+	std::vector<ZCutscene*> cutscenes;
+	std::vector<CutsceneEntry> cutsceneEntries;  // (MM Only)
+	uint8_t numCutscenes;                        // (MM Only)
+
+	SetCutscenes(ZFile* nParent);
+
+	void ParseRawData() override;
+	void DeclareReferences(const std::string& prefix) override;
+
+	std::string GetBodySourceCode() const override;
+
+	RoomCommand GetRoomCommand() const override;
+	std::string GetCommandCName() const override;
+};

ZAPDTR/ZAPD/ZRoom/Commands/SetEchoSettings.cpp

@@ -0,0 +1,27 @@
+#include "SetEchoSettings.h"
+#include "Utils/StringHelper.h"
+
+SetEchoSettings::SetEchoSettings(ZFile* nParent) : ZRoomCommand(nParent)
+{
+}
+
+void SetEchoSettings::ParseRawData()
+{
+	ZRoomCommand::ParseRawData();
+	echo = parent->GetRawData().at(rawDataIndex + 0x07);
+}
+
+std::string SetEchoSettings::GetBodySourceCode() const
+{
+	return StringHelper::Sprintf("SCENE_CMD_ECHO_SETTINGS(%i)", echo);
+}
+
+std::string SetEchoSettings::GetCommandCName() const
+{
+	return "SCmdEchoSettings";
+}
+
+RoomCommand SetEchoSettings::GetRoomCommand() const
+{
+	return RoomCommand::SetEchoSettings;
+}

ZAPDTR/ZAPD/ZRoom/Commands/SetEchoSettings.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "ZRoom/ZRoomCommand.h"
+
+class SetEchoSettings : public ZRoomCommand
+{
+public:
+	uint8_t echo;
+
+	SetEchoSettings(ZFile* nParent);
+
+	void ParseRawData() override;
+
+	std::string GetBodySourceCode() const override;
+
+	std::string GetCommandCName() const override;
+	RoomCommand GetRoomCommand() const override;
+};

ZAPDTR/ZAPD/ZRoom/Commands/SetEntranceList.cpp

@@ -0,0 +1,91 @@
+#include "SetEntranceList.h"
+
+#include "Globals.h"
+#include "SetStartPositionList.h"
+#include "Utils/BitConverter.h"
+#include "Utils/StringHelper.h"
+#include "ZFile.h"
+#include "ZRoom/ZRoom.h"
+
+SetEntranceList::SetEntranceList(ZFile* nParent) : ZRoomCommand(nParent)
+{
+}
+
+void SetEntranceList::DeclareReferences([[maybe_unused]] const std::string& prefix)
+{
+	if (segmentOffset != 0)
+	{
+		std::string varName =
+			StringHelper::Sprintf("%sEntranceList0x%06X", prefix.c_str(), segmentOffset);
+		parent->AddDeclarationPlaceholder(segmentOffset, varName);
+	}
+}
+
+void SetEntranceList::ParseRawDataLate()
+{
+	// Parse Entrances and Generate Declaration
+	uint32_t numEntrances = zRoom->GetDeclarationSizeFromNeighbor(segmentOffset) / 2;
+	uint32_t currentPtr = segmentOffset;
+
+	entrances.reserve(numEntrances);
+	for (uint32_t i = 0; i < numEntrances; i++)
+	{
+		EntranceEntry entry(parent->GetRawData(), currentPtr);
+		entrances.push_back(entry);
+
+		currentPtr += 2;
+	}
+}
+
+void SetEntranceList::DeclareReferencesLate([[maybe_unused]] const std::string& prefix)
+{
+	if (!entrances.empty())
+	{
+		std::string declaration;
+
+		size_t index = 0;
+		for (const auto& entry : entrances)
+		{
+			declaration += StringHelper::Sprintf("    { %s },", entry.GetBodySourceCode().c_str());
+			if (index + 1 < entrances.size())
+				declaration += "\n";
+
+			index++;
+		}
+
+		std::string varName =
+			StringHelper::Sprintf("%sEntranceList0x%06X", prefix.c_str(), segmentOffset);
+		parent->AddDeclarationArray(segmentOffset, DeclarationAlignment::Align4,
+		                            entrances.size() * 2, "EntranceEntry", varName,
+		                            entrances.size(), declaration);
+	}
+}
+
+std::string SetEntranceList::GetBodySourceCode() const
+{
+	std::string listName;
+	Globals::Instance->GetSegmentedPtrName(cmdArg2, parent, "EntranceEntry", listName,
+	                                       parent->workerID);
+	return StringHelper::Sprintf("SCENE_CMD_ENTRANCE_LIST(%s)", listName.c_str());
+}
+
+std::string SetEntranceList::GetCommandCName() const
+{
+	return "SCmdEntranceList";
+}
+
+RoomCommand SetEntranceList::GetRoomCommand() const
+{
+	return RoomCommand::SetEntranceList;
+}
+
+EntranceEntry::EntranceEntry(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex)
+{
+	startPositionIndex = rawData.at(rawDataIndex + 0);
+	roomToLoad = rawData.at(rawDataIndex + 1);
+}
+
+std::string EntranceEntry::GetBodySourceCode() const
+{
+	return StringHelper::Sprintf("0x%02X, 0x%02X", startPositionIndex, roomToLoad);
+}

ZAPDTR/ZAPD/ZRoom/Commands/SetEntranceList.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include "ZRoom/ZRoomCommand.h"
+
+class EntranceEntry
+{
+public:
+	uint8_t startPositionIndex;
+	uint8_t roomToLoad;
+
+	EntranceEntry(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex);
+
+	std::string GetBodySourceCode() const;
+};
+
+class SetEntranceList : public ZRoomCommand
+{
+public:
+	std::vector<EntranceEntry> entrances;
+
+	SetEntranceList(ZFile* nParent);
+
+	void DeclareReferences(const std::string& prefix) override;
+	void ParseRawDataLate() override;
+	void DeclareReferencesLate(const std::string& prefix) override;
+
+	std::string GetBodySourceCode() const override;
+
+	RoomCommand GetRoomCommand() const override;
+	std::string GetCommandCName() const override;
+};

ZAPDTR/ZAPD/ZRoom/Commands/SetExitList.cpp

@@ -0,0 +1,76 @@
+#include "SetExitList.h"
+
+#include "Globals.h"
+#include "Utils/BitConverter.h"
+#include "Utils/StringHelper.h"
+#include "ZFile.h"
+#include "ZRoom/ZNames.h"
+#include "ZRoom/ZRoom.h"
+
+SetExitList::SetExitList(ZFile* nParent) : ZRoomCommand(nParent)
+{
+}
+
+void SetExitList::DeclareReferences([[maybe_unused]] const std::string& prefix)
+{
+	if (segmentOffset != 0)
+	{
+		std::string varName =
+			StringHelper::Sprintf("%sExitList_%06X", prefix.c_str(), segmentOffset);
+		parent->AddDeclarationPlaceholder(segmentOffset, varName);
+	}
+}
+
+void SetExitList::ParseRawDataLate()
+{
+	// Parse Entrances and Generate Declaration
+	uint32_t numEntrances = zRoom->GetDeclarationSizeFromNeighbor(segmentOffset) / 2;
+	uint32_t currentPtr = segmentOffset;
+
+	exits.reserve(numEntrances);
+	for (uint32_t i = 0; i < numEntrances; i++)
+	{
+		uint16_t exit = BitConverter::ToUInt16BE(parent->GetRawData(), currentPtr);
+		exits.push_back(exit);
+
+		currentPtr += 2;
+	}
+}
+
+void SetExitList::DeclareReferencesLate([[maybe_unused]] const std::string& prefix)
+{
+	if (!exits.empty())
+	{
+		std::string declaration;
+
+		for (size_t i = 0; i < exits.size(); i++)
+		{
+			declaration +=
+				StringHelper::Sprintf("    %s,", ZNames::GetEntranceName(exits[i]).c_str());
+			if (i + 1 < exits.size())
+				declaration += "\n";
+		}
+
+		std::string varName =
+			StringHelper::Sprintf("%sExitList_%06X", prefix.c_str(), segmentOffset);
+		parent->AddDeclarationArray(segmentOffset, DeclarationAlignment::Align4, exits.size() * 2,
+		                            "u16", varName, exits.size(), declaration);
+	}
+}
+
+std::string SetExitList::GetBodySourceCode() const
+{
+	std::string listName;
+	Globals::Instance->GetSegmentedPtrName(cmdArg2, parent, "u16", listName, parent->workerID);
+	return StringHelper::Sprintf("SCENE_CMD_EXIT_LIST(%s)", listName.c_str());
+}
+
+std::string SetExitList::GetCommandCName() const
+{
+	return "SCmdExitList";
+}
+
+RoomCommand SetExitList::GetRoomCommand() const
+{
+	return RoomCommand::SetExitList;
+}

ZAPDTR/ZAPD/ZRoom/Commands/SetExitList.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include "ZRoom/ZRoomCommand.h"
+
+class SetExitList : public ZRoomCommand
+{
+public:
+	std::vector<uint16_t> exits;
+
+	SetExitList(ZFile* nParent);
+
+	void DeclareReferences(const std::string& prefix) override;
+	void ParseRawDataLate() override;
+	void DeclareReferencesLate(const std::string& prefix) override;
+
+	std::string GetBodySourceCode() const override;
+
+	RoomCommand GetRoomCommand() const override;
+	std::string GetCommandCName() const override;
+};

ZAPDTR/ZAPD/ZRoom/Commands/SetLightList.cpp

@@ -0,0 +1,100 @@
+#include "SetLightList.h"
+
+#include "Globals.h"
+#include "Utils/BitConverter.h"
+#include "Utils/StringHelper.h"
+
+SetLightList::SetLightList(ZFile* nParent) : ZRoomCommand(nParent)
+{
+}
+
+void SetLightList::ParseRawData()
+{
+	ZRoomCommand::ParseRawData();
+	std::string declarations;
+
+	numLights = cmdArg1;
+	int32_t currentPtr = segmentOffset;
+
+	lights.reserve(this->numLights);
+	for (int i = 0; i < this->numLights; i++)
+	{
+		LightInfo light(parent->GetRawData(), currentPtr);
+
+		currentPtr += light.GetRawDataSize();
+		lights.push_back(light);
+	}
+}
+
+void SetLightList::DeclareReferences(const std::string& prefix)
+{
+	if (!lights.empty())
+	{
+		std::string declarations;
+
+		for (size_t i = 0; i < lights.size(); i++)
+		{
+			declarations +=
+				StringHelper::Sprintf("\t{ %s },", lights.at(i).GetBodySourceCode().c_str());
+
+			if (i < lights.size() - 1)
+				declarations += "\n";
+		}
+
+		const auto& light = lights.front();
+
+		parent->AddDeclarationArray(
+			segmentOffset, DeclarationAlignment::Align4, lights.size() * light.GetRawDataSize(),
+			light.GetSourceTypeName(),
+			StringHelper::Sprintf("%sLightInfo0x%06X", prefix.c_str(), segmentOffset),
+			lights.size(), declarations);
+	}
+}
+
+std::string SetLightList::GetBodySourceCode() const
+{
+	std::string listName;
+	Globals::Instance->GetSegmentedPtrName(cmdArg2, parent, "LightInfo", listName,
+	                                       parent->workerID);
+	return StringHelper::Sprintf("SCENE_CMD_LIGHT_LIST(%i, %s)", numLights, listName.c_str());
+}
+
+std::string SetLightList::GetCommandCName() const
+{
+	return "SCmdLightList";
+}
+
+RoomCommand SetLightList::GetRoomCommand() const
+{
+	return RoomCommand::SetLightList;
+}
+
+LightInfo::LightInfo(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex)
+{
+	type = BitConverter::ToUInt8BE(rawData, rawDataIndex + 0);
+	x = BitConverter::ToInt16BE(rawData, rawDataIndex + 2);
+	y = BitConverter::ToInt16BE(rawData, rawDataIndex + 4);
+	z = BitConverter::ToInt16BE(rawData, rawDataIndex + 6);
+	r = BitConverter::ToUInt8BE(rawData, rawDataIndex + 8);
+	g = BitConverter::ToUInt8BE(rawData, rawDataIndex + 9);
+	b = BitConverter::ToUInt8BE(rawData, rawDataIndex + 10);
+	drawGlow = BitConverter::ToUInt8BE(rawData, rawDataIndex + 11);
+	radius = BitConverter::ToInt16BE(rawData, rawDataIndex + 12);
+}
+
+std::string LightInfo::GetBodySourceCode() const
+{
+	return StringHelper::Sprintf(
+		"0x%02X, { %i, %i, %i, { 0x%02X, 0x%02X, 0x%02X }, 0x%02X, 0x%04X }", type, x, y, z, r, g,
+		b, drawGlow, radius);
+}
+
+std::string LightInfo::GetSourceTypeName() const
+{
+	return "LightInfo";
+}
+
+size_t LightInfo::GetRawDataSize() const
+{
+	return 0x0E;
+}

ZAPDTR/ZAPD/ZRoom/Commands/SetLightList.h

@@ -0,0 +1,42 @@
+#pragma once
+
+#include <string>
+
+#include "ZFile.h"
+#include "ZRoom/ZRoom.h"
+#include "ZRoom/ZRoomCommand.h"
+
+class LightInfo
+{
+public:
+	LightInfo(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex);
+
+	std::string GetBodySourceCode() const;
+
+	std::string GetSourceTypeName() const;
+	size_t GetRawDataSize() const;
+
+public:
+	uint8_t type;
+	int16_t x, y, z;
+	uint8_t r, g, b;
+	uint8_t drawGlow;
+	int16_t radius;
+};
+
+class SetLightList : public ZRoomCommand
+{
+public:
+	uint8_t numLights;
+	std::vector<LightInfo> lights;
+
+	SetLightList(ZFile* nParent);
+
+	void ParseRawData() override;
+	void DeclareReferences(const std::string& prefix) override;
+
+	std::string GetBodySourceCode() const override;
+
+	RoomCommand GetRoomCommand() const override;
+	std::string GetCommandCName() const override;
+};

ZAPDTR/ZAPD/ZRoom/Commands/SetLightingSettings.cpp

@@ -0,0 +1,107 @@
+#include "SetLightingSettings.h"
+
+#include "Globals.h"
+#include "Utils/BitConverter.h"
+#include "Utils/StringHelper.h"
+#include "ZFile.h"
+#include "ZRoom/ZRoom.h"
+
+SetLightingSettings::SetLightingSettings(ZFile* nParent) : ZRoomCommand(nParent)
+{
+}
+
+void SetLightingSettings::ParseRawData()
+{
+	ZRoomCommand::ParseRawData();
+	uint8_t numLights = cmdArg1;
+
+	settings.reserve(numLights);
+	for (int i = 0; i < numLights; i++)
+		settings.push_back(LightingSettings(parent->GetRawData(), segmentOffset + (i * 22)));
+}
+
+void SetLightingSettings::DeclareReferences(const std::string& prefix)
+{
+	if (settings.size() > 0)
+	{
+		std::string declaration;
+
+		for (size_t i = 0; i < settings.size(); i++)
+		{
+			declaration +=
+				StringHelper::Sprintf("\t{ %s },", settings.at(i).GetBodySourceCode().c_str());
+			if (i + 1 < settings.size())
+				declaration += "\n";
+		}
+
+		parent->AddDeclarationArray(
+			segmentOffset, DeclarationAlignment::Align4,
+			settings.size() * settings.front().GetRawDataSize(), "LightSettings",
+			StringHelper::Sprintf("%sLightSettings0x%06X", prefix.c_str(), segmentOffset),
+			settings.size(), declaration);
+	}
+}
+
+std::string SetLightingSettings::GetBodySourceCode() const
+{
+	std::string listName;
+	Globals::Instance->GetSegmentedPtrName(cmdArg2, parent, "LightSettings", listName,
+	                                       parent->workerID);
+	return StringHelper::Sprintf("SCENE_CMD_ENV_LIGHT_SETTINGS(%i, %s)", settings.size(),
+	                             listName.c_str());
+}
+
+std::string SetLightingSettings::GetCommandCName() const
+{
+	return "SCmdLightSettingList";
+}
+
+RoomCommand SetLightingSettings::GetRoomCommand() const
+{
+	return RoomCommand::SetLightingSettings;
+}
+
+LightingSettings::LightingSettings(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex)
+{
+	ambientClrR = rawData.at(rawDataIndex + 0);
+	ambientClrG = rawData.at(rawDataIndex + 1);
+	ambientClrB = rawData.at(rawDataIndex + 2);
+
+	diffuseClrA_R = rawData.at(rawDataIndex + 3);
+	diffuseClrA_G = rawData.at(rawDataIndex + 4);
+	diffuseClrA_B = rawData.at(rawDataIndex + 5);
+
+	diffuseDirA_X = rawData.at(rawDataIndex + 6);
+	diffuseDirA_Y = rawData.at(rawDataIndex + 7);
+	diffuseDirA_Z = rawData.at(rawDataIndex + 8);
+
+	diffuseClrB_R = rawData.at(rawDataIndex + 9);
+	diffuseClrB_G = rawData.at(rawDataIndex + 10);
+	diffuseClrB_B = rawData.at(rawDataIndex + 11);
+
+	diffuseDirB_X = rawData.at(rawDataIndex + 12);
+	diffuseDirB_Y = rawData.at(rawDataIndex + 13);
+	diffuseDirB_Z = rawData.at(rawDataIndex + 14);
+
+	fogClrR = rawData.at(rawDataIndex + 15);
+	fogClrG = rawData.at(rawDataIndex + 16);
+	fogClrB = rawData.at(rawDataIndex + 17);
+
+	unk = BitConverter::ToInt16BE(rawData, rawDataIndex + 18);
+	drawDistance = BitConverter::ToInt16BE(rawData, rawDataIndex + 20);
+}
+
+std::string LightingSettings::GetBodySourceCode() const
+{
+	return StringHelper::Sprintf(
+		"0x%02X, 0x%02X, 0x%02X, 0x%02X, 0x%02X, 0x%02X, 0x%02X, 0x%02X, 0x%02X, 0x%02X, 0x%02X, "
+		"0x%02X, 0x%02X, 0x%02X, 0x%02X, 0x%02X, 0x%02X, 0x%02X, 0x%04X, 0x%04X",
+		ambientClrR, ambientClrG, ambientClrB, diffuseClrA_R, diffuseClrA_G, diffuseClrA_B,
+		diffuseDirA_X, diffuseDirA_Y, diffuseDirA_Z, diffuseClrB_R, diffuseClrB_G, diffuseClrB_B,
+		diffuseDirB_X, diffuseDirB_Y, diffuseDirB_Z, fogClrR, fogClrG, fogClrB, unk, drawDistance);
+}
+
+size_t LightingSettings::GetRawDataSize() const
+{
+	return 0x16;
+}

ZAPDTR/ZAPD/ZRoom/Commands/SetLightingSettings.h

@@ -0,0 +1,38 @@
+#pragma once
+
+#include "ZRoom/ZRoomCommand.h"
+
+class LightingSettings
+{
+public:
+	uint8_t ambientClrR, ambientClrG, ambientClrB;
+	uint8_t diffuseClrA_R, diffuseClrA_G, diffuseClrA_B;
+	uint8_t diffuseDirA_X, diffuseDirA_Y, diffuseDirA_Z;
+	uint8_t diffuseClrB_R, diffuseClrB_G, diffuseClrB_B;
+	uint8_t diffuseDirB_X, diffuseDirB_Y, diffuseDirB_Z;
+	uint8_t fogClrR, fogClrG, fogClrB;
+	uint16_t unk;
+	uint16_t drawDistance;
+
+	LightingSettings(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex);
+
+	std::string GetBodySourceCode() const;
+
+	size_t GetRawDataSize() const;
+};
+
+class SetLightingSettings : public ZRoomCommand
+{
+public:
+	std::vector<LightingSettings> settings;
+
+	SetLightingSettings(ZFile* nParent);
+
+	void ParseRawData() override;
+	void DeclareReferences(const std::string& prefix) override;
+
+	std::string GetBodySourceCode() const override;
+
+	RoomCommand GetRoomCommand() const override;
+	std::string GetCommandCName() const override;
+};

ZAPDTR/ZAPD/ZRoom/Commands/SetMesh.cpp

@@ -0,0 +1,616 @@
+#include "SetMesh.h"
+
+#include "Globals.h"
+#include "Utils/BitConverter.h"
+#include "Utils/Path.h"
+#include "Utils/StringHelper.h"
+#include "WarningHandler.h"
+#include "ZBackground.h"
+#include "ZFile.h"
+#include "ZRoom/ZRoom.h"
+
+void GenDListDeclarations(ZRoom* zRoom, ZFile* parent, ZDisplayList* dList);
+
+SetMesh::SetMesh(ZFile* nParent) : ZRoomCommand(nParent)
+{
+}
+
+void SetMesh::ParseRawData()
+{
+	ZRoomCommand::ParseRawData();
+	auto& parentRawData = parent->GetRawData();
+	meshHeaderType = parentRawData.at(segmentOffset);
+
+	switch (meshHeaderType)
+	{
+	case 0:
+		polyType = std::make_shared<PolygonType2>(parent, segmentOffset, zRoom);
+		break;
+
+	case 1:
+		polyType = std::make_shared<PolygonType1>(parent, segmentOffset, zRoom);
+		break;
+
+	case 2:
+		polyType = std::make_shared<PolygonType2>(parent, segmentOffset, zRoom);
+		break;
+
+	default:
+		HANDLE_ERROR(WarningType::InvalidExtractedData,
+		             StringHelper::Sprintf("unknown meshHeaderType: %i", meshHeaderType), "");
+	}
+
+	polyType->ParseRawData();
+}
+
+void SetMesh::DeclareReferences(const std::string& prefix)
+{
+	polyType->SetName(polyType->GetDefaultName(prefix));
+	polyType->DeclareReferences(prefix);
+	polyType->DeclareAndGenerateOutputCode(prefix);
+}
+
+// TODO: is this really needed?
+void GenDListDeclarations(ZRoom* zRoom, ZFile* parent, ZDisplayList* dList)
+{
+	if (dList == nullptr)
+		return;
+
+	dList->DeclareReferences(zRoom->GetName());
+
+	for (ZDisplayList* otherDList : dList->otherDLists)
+		GenDListDeclarations(zRoom, parent, otherDList);
+}
+
+std::string SetMesh::GenDListExterns(ZDisplayList* dList)
+{
+	std::string sourceOutput;
+
+	sourceOutput += StringHelper::Sprintf("extern Gfx %sDL_%06X[];\n", zRoom->GetName().c_str(),
+	                                      dList->GetRawDataIndex());
+
+	for (ZDisplayList* otherDList : dList->otherDLists)
+		sourceOutput += GenDListExterns(otherDList);
+
+	return sourceOutput;
+}
+
+std::string SetMesh::GetBodySourceCode() const
+{
+	std::string list;
+	Globals::Instance->GetSegmentedPtrName(cmdArg2, parent, "", list, parent->workerID);
+	return StringHelper::Sprintf("SCENE_CMD_MESH(%s)", list.c_str());
+}
+
+std::string SetMesh::GetCommandCName() const
+{
+	return "SCmdMesh";
+}
+
+RoomCommand SetMesh::GetRoomCommand() const
+{
+	return RoomCommand::SetMesh;
+}
+
+PolygonDlist::PolygonDlist(ZFile* nParent) : ZResource(nParent)
+{
+}
+
+void PolygonDlist::ParseRawData()
+{
+	const auto& rawData = parent->GetRawData();
+	switch (polyType)
+	{
+	case 2:
+		x = BitConverter::ToInt16BE(rawData, rawDataIndex + 0);
+		y = BitConverter::ToInt16BE(rawData, rawDataIndex + 2);
+		z = BitConverter::ToInt16BE(rawData, rawDataIndex + 4);
+		unk_06 = BitConverter::ToInt16BE(rawData, rawDataIndex + 6);
+
+		opa = BitConverter::ToUInt32BE(rawData, rawDataIndex + 8);
+		xlu = BitConverter::ToUInt32BE(rawData, rawDataIndex + 12);
+		break;
+
+	default:
+		opa = BitConverter::ToUInt32BE(rawData, rawDataIndex);
+		xlu = BitConverter::ToUInt32BE(rawData, rawDataIndex + 4);
+		break;
+	}
+}
+
+void PolygonDlist::DeclareReferences(const std::string& prefix)
+{
+	opaDList = MakeDlist(opa, prefix);
+	xluDList = MakeDlist(xlu, prefix);
+}
+
+std::string PolygonDlist::GetBodySourceCode() const
+{
+	std::string bodyStr;
+	std::string opaStr;
+	std::string xluStr;
+	Globals::Instance->GetSegmentedPtrName(opa, parent, "Gfx", opaStr, parent->workerID);
+	Globals::Instance->GetSegmentedPtrName(xlu, parent, "Gfx", xluStr, parent->workerID);
+
+	if (polyType == 2)
+	{
+		bodyStr += StringHelper::Sprintf("{ %6i, %6i, %6i }, %6i, ", x, y, z, unk_06);
+	}
+
+	bodyStr += StringHelper::Sprintf("%s, %s", opaStr.c_str(), xluStr.c_str());
+
+	return bodyStr;
+}
+
+void PolygonDlist::GetSourceOutputCode(const std::string& prefix)
+{
+	std::string bodyStr = StringHelper::Sprintf("\n\t%s\n", GetBodySourceCode().c_str());
+
+	Declaration* decl = parent->GetDeclaration(rawDataIndex);
+
+	if (decl == nullptr)
+		DeclareVar(prefix, bodyStr);
+	else
+		decl->text = bodyStr;
+}
+
+std::string PolygonDlist::GetSourceTypeName() const
+{
+	switch (polyType)
+	{
+	case 2:
+		return "PolygonDlist2";
+
+	default:
+		return "PolygonDlist";
+	}
+}
+
+ZResourceType PolygonDlist::GetResourceType() const
+{
+	// TODO
+	return ZResourceType::Error;
+}
+
+size_t PolygonDlist::GetRawDataSize() const
+{
+	switch (polyType)
+	{
+	case 2:
+		return 0x10;
+
+	default:
+		return 0x08;
+	}
+}
+
+void PolygonDlist::SetPolyType(uint8_t nPolyType)
+{
+	polyType = nPolyType;
+}
+
+ZDisplayList* PolygonDlist::MakeDlist(segptr_t ptr, [[maybe_unused]] const std::string& prefix)
+{
+	if (ptr == 0)
+	{
+		return nullptr;
+	}
+
+	uint32_t dlistAddress = Seg2Filespace(ptr, parent->baseAddress);
+
+	int32_t dlistLength = ZDisplayList::GetDListLength(
+		parent->GetRawData(), dlistAddress,
+		Globals::Instance->game == ZGame::OOT_SW97 ? DListType::F3DEX : DListType::F3DZEX);
+	ZDisplayList* dlist = new ZDisplayList(parent);
+	parent->AddResource(dlist);
+	dlist->ExtractFromBinary(dlistAddress, dlistLength);
+	dlist->SetName(dlist->GetDefaultName(prefix));
+	GenDListDeclarations(zRoom, parent, dlist);
+
+	return dlist;
+}
+
+/* BgImage */
+
+BgImage::BgImage(ZFile* nParent) : ZResource(nParent)
+{
+}
+
+BgImage::BgImage(bool nIsSubStruct, const std::string& prefix, uint32_t nRawDataIndex,
+                 ZFile* nParent)
+	: BgImage(nParent)
+{
+	rawDataIndex = nRawDataIndex;
+	parent = nParent;
+	isSubStruct = nIsSubStruct;
+
+	name = GetDefaultName(prefix);
+
+	ParseRawData();
+	sourceBackground = MakeBackground(source, prefix);
+}
+
+void BgImage::ParseRawData()
+{
+	size_t pad = 0x00;
+	const auto& rawData = parent->GetRawData();
+	if (!isSubStruct)
+	{
+		pad = 0x04;
+
+		unk_00 = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0x00);
+		id = BitConverter::ToUInt8BE(rawData, rawDataIndex + 0x02);
+	}
+	source = BitConverter::ToUInt32BE(rawData, rawDataIndex + pad + 0x00);
+	unk_0C = BitConverter::ToUInt32BE(rawData, rawDataIndex + pad + 0x04);
+	tlut = BitConverter::ToUInt32BE(rawData, rawDataIndex + pad + 0x08);
+	width = BitConverter::ToUInt16BE(rawData, rawDataIndex + pad + 0x0C);
+	height = BitConverter::ToUInt16BE(rawData, rawDataIndex + pad + 0x0E);
+	fmt = BitConverter::ToUInt8BE(rawData, rawDataIndex + pad + 0x10);
+	siz = BitConverter::ToUInt8BE(rawData, rawDataIndex + pad + 0x11);
+	mode0 = BitConverter::ToUInt16BE(rawData, rawDataIndex + pad + 0x12);
+	tlutCount = BitConverter::ToUInt16BE(rawData, rawDataIndex + pad + 0x14);
+}
+
+ZBackground* BgImage::MakeBackground(segptr_t ptr, const std::string& prefix)
+{
+	if (ptr == 0)
+		return nullptr;
+
+	uint32_t backAddress = Seg2Filespace(ptr, parent->baseAddress);
+
+	ZBackground* background = new ZBackground(parent);
+	background->ExtractFromFile(backAddress);
+
+	std::string defaultName = background->GetDefaultName(prefix);
+	background->SetName(defaultName);
+	background->SetOutName(defaultName);
+
+	background->DeclareVar(prefix, "");
+	parent->resources.push_back(background);
+
+	return background;
+}
+
+size_t BgImage::GetRawDataSize() const
+{
+	return 0x1C;
+}
+
+std::string BgImage::GetBodySourceCode() const
+{
+	std::string bodyStr = "    ";
+	if (!isSubStruct)
+	{
+		bodyStr += "{ \n        ";
+	}
+
+	if (!isSubStruct)
+	{
+		bodyStr += StringHelper::Sprintf("0x%04X, ", unk_00);
+		bodyStr += StringHelper::Sprintf("%i, ", id);
+		bodyStr += "\n    ";
+		bodyStr += "    ";
+	}
+
+	std::string backgroundName;
+	Globals::Instance->GetSegmentedPtrName(source, parent, "", backgroundName, parent->workerID);
+	bodyStr += StringHelper::Sprintf("%s, ", backgroundName.c_str());
+	bodyStr += "\n    ";
+	if (!isSubStruct)
+	{
+		bodyStr += "    ";
+	}
+
+	bodyStr += StringHelper::Sprintf("0x%08X, ", unk_0C);
+	bodyStr += StringHelper::Sprintf("0x%08X, ", tlut);
+	bodyStr += "\n    ";
+	if (!isSubStruct)
+	{
+		bodyStr += "    ";
+	}
+
+	bodyStr += StringHelper::Sprintf("%i, ", width);
+	bodyStr += StringHelper::Sprintf("%i, ", height);
+	bodyStr += "\n    ";
+	if (!isSubStruct)
+	{
+		bodyStr += "    ";
+	}
+
+	bodyStr += StringHelper::Sprintf("%i, ", fmt);
+	bodyStr += StringHelper::Sprintf("%i, ", siz);
+	bodyStr += "\n    ";
+	if (!isSubStruct)
+	{
+		bodyStr += "    ";
+	}
+
+	bodyStr += StringHelper::Sprintf("0x%04X, ", mode0);
+	bodyStr += StringHelper::Sprintf("0x%04X, ", tlutCount);
+	if (!isSubStruct)
+	{
+		bodyStr += " \n    }, ";
+	}
+	else
+	{
+		bodyStr += "\n";
+	}
+
+	return bodyStr;
+}
+
+std::string BgImage::GetSourceTypeName() const
+{
+	return "BgImage";
+}
+
+ZResourceType BgImage::GetResourceType() const
+{
+	// TODO
+	return ZResourceType::Error;
+}
+
+/* PolygonType section */
+
+PolygonTypeBase::PolygonTypeBase(ZFile* nParent, uint32_t nRawDataIndex, ZRoom* nRoom)
+	: ZResource(nParent), zRoom{nRoom}
+{
+	rawDataIndex = nRawDataIndex;
+	type = BitConverter::ToUInt8BE(parent->GetRawData(), rawDataIndex);
+}
+
+void PolygonTypeBase::DeclareAndGenerateOutputCode(const std::string& prefix)
+{
+	std::string bodyStr = GetBodySourceCode();
+
+	Declaration* decl = parent->GetDeclaration(rawDataIndex);
+	if (decl == nullptr)
+	{
+		DeclareVar(prefix, bodyStr);
+	}
+	else
+	{
+		decl->text = bodyStr;
+	}
+}
+
+std::string PolygonTypeBase::GetSourceTypeName() const
+{
+	switch (type)
+	{
+	case 2:
+		return "PolygonType2";
+
+	case 1:
+		return "PolygonType1";
+
+	default:
+		return "PolygonType0";
+	}
+}
+
+ZResourceType PolygonTypeBase::GetResourceType() const
+{
+	// TODO
+	return ZResourceType::Error;
+}
+
+PolygonType1::PolygonType1(ZFile* nParent, uint32_t nRawDataIndex, ZRoom* nRoom)
+	: PolygonTypeBase(nParent, nRawDataIndex, nRoom), single(nParent)
+{
+}
+
+void PolygonType1::ParseRawData()
+{
+	const auto& rawData = parent->GetRawData();
+
+	format = BitConverter::ToUInt8BE(rawData, rawDataIndex + 0x01);
+	dlist = BitConverter::ToUInt32BE(rawData, rawDataIndex + 0x04);
+
+	if (format == 2)
+	{
+		count = BitConverter::ToUInt8BE(rawData, rawDataIndex + 0x08);
+		list = BitConverter::ToUInt32BE(rawData, rawDataIndex + 0x0C);
+	}
+
+	if (dlist != 0)
+	{
+		PolygonDlist polyGfxList(parent);
+		polyGfxList.zRoom = zRoom;
+		polyGfxList.SetPolyType(type);
+		polyGfxList.ExtractFromFile(Seg2Filespace(dlist, parent->baseAddress));
+		polyGfxList.DeclareReferences(zRoom->GetName());
+		polyDLists.push_back(polyGfxList);
+	}
+}
+
+void PolygonType1::DeclareReferences(const std::string& prefix)
+{
+	polyDLists.at(0).GetSourceOutputCode(prefix);
+
+	uint32_t listAddress;
+	std::string bgImageArrayBody;
+	switch (format)
+	{
+	case 1:
+		single = BgImage(true, prefix, rawDataIndex + 0x08, parent);
+		break;
+
+	case 2:
+		if (list != 0)
+		{
+			listAddress = Seg2Filespace(list, parent->baseAddress);
+			uint32_t auxPtr = listAddress;
+
+			multiList.reserve(count);
+			for (size_t i = 0; i < count; ++i)
+			{
+				BgImage bg(false, prefix, auxPtr, parent);
+				multiList.push_back(bg);
+				auxPtr += bg.GetRawDataSize();
+				bgImageArrayBody += bg.GetBodySourceCode();
+				if (i + 1 < count)
+				{
+					bgImageArrayBody += "\n";
+				}
+			}
+
+			Declaration* decl = parent->GetDeclaration(listAddress);
+			if (decl == nullptr)
+			{
+				parent->AddDeclarationArray(
+					listAddress, DeclarationAlignment::Align4,
+					count * multiList.at(0).GetRawDataSize(), multiList.at(0).GetSourceTypeName(),
+					multiList.at(0).GetName().c_str(), count, bgImageArrayBody);
+			}
+		}
+		break;
+
+	default:
+		HANDLE_ERROR(WarningType::InvalidExtractedData,
+		             StringHelper::Sprintf("unknown format: %i", format), "");
+		break;
+	}
+}
+
+size_t PolygonType1::GetRawDataSize() const
+{
+	switch (format)
+	{
+	case 1:
+		return 0x20;
+
+	case 2:
+		return 0x10;
+	}
+	return 0x20;
+}
+
+std::string PolygonType1::GetBodySourceCode() const
+{
+	std::string bodyStr = "\n    ";
+
+	bodyStr += "{ ";
+	bodyStr += StringHelper::Sprintf("%i, %i, ", type, format);
+
+	std::string dlistStr;
+	Globals::Instance->GetSegmentedPtrName(dlist, parent, "", dlistStr, parent->workerID);
+
+	bodyStr += StringHelper::Sprintf("%s, ", dlistStr.c_str());
+	bodyStr += "}, \n";
+
+	std::string listStr = "NULL";
+	switch (format)
+	{
+	case 1:
+		bodyStr += single.GetBodySourceCode();
+		break;
+	case 2:
+		Globals::Instance->GetSegmentedPtrName(list, parent, "BgImage", listStr, parent->workerID);
+		bodyStr += StringHelper::Sprintf("    %i, %s, \n", count, listStr.c_str());
+		break;
+
+	default:
+		break;
+	}
+
+	return bodyStr;
+}
+
+std::string PolygonType1::GetSourceTypeName() const
+{
+	switch (format)
+	{
+	case 1:
+		return "MeshHeader1Single";
+
+	case 2:
+		return "MeshHeader1Multi";
+	}
+	return "ERROR";
+	// return "PolygonType1";
+}
+
+PolygonType2::PolygonType2(ZFile* nParent, uint32_t nRawDataIndex, ZRoom* nRoom)
+	: PolygonTypeBase(nParent, nRawDataIndex, nRoom)
+{
+}
+
+void PolygonType2::ParseRawData()
+{
+	const auto& rawData = parent->GetRawData();
+
+	num = BitConverter::ToUInt8BE(rawData, rawDataIndex + 0x01);
+
+	start = BitConverter::ToUInt32BE(rawData, rawDataIndex + 0x04);
+	end = BitConverter::ToUInt32BE(rawData, rawDataIndex + 0x08);
+
+	uint32_t currentPtr = GETSEGOFFSET(start);
+
+	polyDLists.reserve(num);
+	for (size_t i = 0; i < num; i++)
+	{
+		PolygonDlist entry(parent);
+		entry.zRoom = zRoom;
+		entry.SetPolyType(type);
+		entry.ExtractFromFile(currentPtr);
+		entry.DeclareReferences(zRoom->GetName());
+		polyDLists.push_back(entry);
+		currentPtr += entry.GetRawDataSize();
+	}
+}
+
+void PolygonType2::DeclareReferences(const std::string& prefix)
+{
+	if (num > 0)
+	{
+		std::string declaration;
+
+		for (size_t i = 0; i < polyDLists.size(); i++)
+		{
+			declaration +=
+				StringHelper::Sprintf("\t{ %s },", polyDLists.at(i).GetBodySourceCode().c_str());
+			if (i + 1 < polyDLists.size())
+				declaration += "\n";
+		}
+
+		std::string polyDlistType = polyDLists.at(0).GetSourceTypeName();
+		std::string polyDListName;
+		polyDListName = StringHelper::Sprintf("%s%s_%06X", prefix.c_str(), polyDlistType.c_str(),
+		                                      GETSEGOFFSET(start));
+
+		Declaration* decl = parent->AddDeclarationArray(
+			GETSEGOFFSET(start), DeclarationAlignment::Align4,
+			polyDLists.size() * polyDLists.at(0).GetRawDataSize(), polyDlistType, polyDListName,
+			polyDLists.size(), declaration);
+		decl->forceArrayCnt = true;
+	}
+
+	parent->AddDeclaration(GETSEGOFFSET(end), DeclarationAlignment::Align4, 4, "s32",
+	                       StringHelper::Sprintf("%s_terminatorMaybe_%06X",
+	                                             parent->GetName().c_str(), GETSEGOFFSET(end)),
+	                       "0x01000000");
+}
+
+std::string PolygonType2::GetBodySourceCode() const
+{
+	std::string listName;
+	Globals::Instance->GetSegmentedPtrName(start, parent, "", listName, parent->workerID);
+
+	std::string body = StringHelper::Sprintf("\n    %i, %i,\n", type, polyDLists.size());
+	body += StringHelper::Sprintf("    %s,\n", listName.c_str());
+	body +=
+		StringHelper::Sprintf("    %s + ARRAY_COUNTU(%s)\n", listName.c_str(), listName.c_str());
+	return body;
+}
+
+size_t PolygonType2::GetRawDataSize() const
+{
+	return 0x0C;
+}
+
+DeclarationAlignment PolygonType2::GetDeclarationAlignment() const
+{
+	return DeclarationAlignment::Align4;
+}

ZAPDTR/ZAPD/ZRoom/Commands/SetMesh.h

@@ -0,0 +1,159 @@
+#pragma once
+
+#include <memory>
+#include "ZBackground.h"
+#include "ZDisplayList.h"
+#include "ZRoom/ZRoomCommand.h"
+
+class PolygonDlist : public ZResource
+{
+public:
+	ZRoom* zRoom;
+
+	uint8_t polyType;
+
+	int16_t x, y, z;  // polyType == 2
+	int16_t unk_06;   // polyType == 2
+
+	segptr_t opa = 0;  // Gfx*
+	segptr_t xlu = 0;  // Gfx*
+
+	ZDisplayList* opaDList = nullptr;  // Gfx*
+	ZDisplayList* xluDList = nullptr;  // Gfx*
+
+	PolygonDlist(ZFile* nParent);
+
+	void ParseRawData() override;
+	void DeclareReferences(const std::string& prefix) override;
+
+	std::string GetBodySourceCode() const override;
+
+	void GetSourceOutputCode(const std::string& prefix) override;
+
+	std::string GetSourceTypeName() const override;
+	ZResourceType GetResourceType() const override;
+
+	size_t GetRawDataSize() const override;
+
+	void SetPolyType(uint8_t nPolyType);
+
+protected:
+	ZDisplayList* MakeDlist(segptr_t ptr, const std::string& prefix);
+};
+
+class BgImage : public ZResource
+{
+public:
+	uint16_t unk_00;
+	uint8_t id;
+	segptr_t source;
+	uint32_t unk_0C;
+	uint32_t tlut;
+	uint16_t width;
+	uint16_t height;
+	uint8_t fmt;
+	uint8_t siz;
+	uint16_t mode0;
+	uint16_t tlutCount;
+
+	ZBackground* sourceBackground;
+
+	bool isSubStruct;
+
+	BgImage(ZFile* nParent);
+	BgImage(bool nIsSubStruct, const std::string& prefix, uint32_t nRawDataIndex, ZFile* nParent);
+
+	void ParseRawData() override;
+
+	std::string GetBodySourceCode() const override;
+
+	std::string GetSourceTypeName() const override;
+	ZResourceType GetResourceType() const override;
+
+	size_t GetRawDataSize() const override;
+
+protected:
+	ZBackground* MakeBackground(segptr_t ptr, const std::string& prefix);
+};
+
+class PolygonTypeBase : public ZResource
+{
+public:
+	uint8_t type;
+	std::vector<PolygonDlist> polyDLists;
+
+	PolygonTypeBase(ZFile* nParent, uint32_t nRawDataIndex, ZRoom* nRoom);
+
+	void DeclareAndGenerateOutputCode(const std::string& prefix);
+
+	std::string GetSourceTypeName() const override;
+	ZResourceType GetResourceType() const override;
+
+protected:
+	ZRoom* zRoom;
+};
+
+class PolygonType1 : public PolygonTypeBase
+{
+public:
+	uint8_t format;
+	segptr_t dlist;
+
+	// single
+	BgImage single;
+
+	// multi
+	uint8_t count;
+	segptr_t list;  // BgImage*
+	std::vector<BgImage> multiList;
+
+	PolygonType1(ZFile* nParent, uint32_t nRawDataIndex, ZRoom* nRoom);
+
+	void ParseRawData() override;
+	void DeclareReferences(const std::string& prefix) override;
+
+	std::string GetBodySourceCode() const override;
+
+	std::string GetSourceTypeName() const override;
+
+	size_t GetRawDataSize() const override;
+};
+
+class PolygonType2 : public PolygonTypeBase
+{
+public:
+	uint8_t num;
+	segptr_t start;
+	segptr_t end;
+
+	PolygonType2(ZFile* nParent, uint32_t nRawDataIndex, ZRoom* nRoom);
+
+	void ParseRawData() override;
+	void DeclareReferences(const std::string& prefix) override;
+
+	std::string GetBodySourceCode() const override;
+
+	size_t GetRawDataSize() const override;
+	DeclarationAlignment GetDeclarationAlignment() const override;
+};
+
+class SetMesh : public ZRoomCommand
+{
+public:
+	uint8_t data;
+	uint8_t meshHeaderType;
+	std::shared_ptr<PolygonTypeBase> polyType;
+
+	SetMesh(ZFile* nParent);
+
+	void ParseRawData() override;
+	void DeclareReferences(const std::string& prefix) override;
+
+	std::string GetBodySourceCode() const override;
+
+	RoomCommand GetRoomCommand() const override;
+	std::string GetCommandCName() const override;
+
+private:
+	std::string GenDListExterns(ZDisplayList* dList);
+};

ZAPDTR/ZAPD/ZRoom/Commands/SetMinimapChests.cpp

@@ -0,0 +1,83 @@
+#include "SetMinimapChests.h"
+
+#include "Globals.h"
+#include "Utils/BitConverter.h"
+#include "Utils/StringHelper.h"
+#include "ZFile.h"
+#include "ZRoom/ZRoom.h"
+
+SetMinimapChests::SetMinimapChests(ZFile* nParent) : ZRoomCommand(nParent)
+{
+}
+
+void SetMinimapChests::ParseRawData()
+{
+	ZRoomCommand::ParseRawData();
+	int numChests = cmdArg1;
+
+	offset_t currentPtr = segmentOffset;
+
+	chests.reserve(numChests);
+	for (int32_t i = 0; i < numChests; i++)
+	{
+		MinimapChest chest(parent->GetRawData(), currentPtr);
+		chests.push_back(chest);
+
+		currentPtr += 10;
+	}
+}
+
+void SetMinimapChests::DeclareReferences(const std::string& prefix)
+{
+	std::string declaration;
+
+	size_t index = 0;
+	for (const auto& chest : chests)
+	{
+		declaration += StringHelper::Sprintf("    { %s },", chest.GetBodySourceCode().c_str());
+
+		if (index < chests.size() - 1)
+			declaration += "\n";
+
+		index++;
+	}
+
+	parent->AddDeclarationArray(
+		segmentOffset, DeclarationAlignment::Align4, chests.size() * 10, "MinimapChest",
+		StringHelper::Sprintf("%sMinimapChests0x%06X", prefix.c_str(), segmentOffset),
+		chests.size(), declaration);
+}
+
+std::string SetMinimapChests::GetBodySourceCode() const
+{
+	std::string listName;
+	Globals::Instance->GetSegmentedPtrName(cmdArg2, parent, "MinimapChest", listName,
+	                                       parent->workerID);
+	return StringHelper::Sprintf("SCENE_CMD_MINIMAP_COMPASS_ICON_INFO(0x%02X, %s)", chests.size(),
+	                             listName.c_str());
+}
+
+std::string SetMinimapChests::GetCommandCName() const
+{
+	return "SCmdMinimapChests";
+}
+
+RoomCommand SetMinimapChests::GetRoomCommand() const
+{
+	return RoomCommand::SetMinimapChests;
+}
+
+MinimapChest::MinimapChest(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex)
+	: unk0(BitConverter::ToUInt16BE(rawData, rawDataIndex + 0)),
+	  unk2(BitConverter::ToUInt16BE(rawData, rawDataIndex + 2)),
+	  unk4(BitConverter::ToUInt16BE(rawData, rawDataIndex + 4)),
+	  unk6(BitConverter::ToUInt16BE(rawData, rawDataIndex + 6)),
+	  unk8(BitConverter::ToUInt16BE(rawData, rawDataIndex + 8))
+{
+}
+
+std::string MinimapChest::GetBodySourceCode() const
+{
+	return StringHelper::Sprintf("0x%04X, 0x%04X, 0x%04X, 0x%04X, 0x%04X", unk0, unk2, unk4, unk6,
+	                             unk8);
+}

ZAPDTR/ZAPD/ZRoom/Commands/SetMinimapChests.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#include "ZRoom/ZRoomCommand.h"
+
+class MinimapChest
+{
+public:
+	MinimapChest(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex);
+
+	std::string GetBodySourceCode() const;
+
+protected:
+	uint16_t unk0;
+	uint16_t unk2;
+	uint16_t unk4;
+	uint16_t unk6;
+	uint16_t unk8;
+};
+
+class SetMinimapChests : public ZRoomCommand
+{
+public:
+	std::vector<MinimapChest> chests;
+
+	SetMinimapChests(ZFile* nParent);
+
+	void ParseRawData() override;
+	void DeclareReferences(const std::string& prefix) override;
+
+	std::string GetBodySourceCode() const override;
+
+	RoomCommand GetRoomCommand() const override;
+	std::string GetCommandCName() const override;
+};

ZAPDTR/ZAPD/ZRoom/Commands/SetMinimapList.cpp

@@ -0,0 +1,98 @@
+#include "SetMinimapList.h"
+
+#include "Globals.h"
+#include "Utils/BitConverter.h"
+#include "Utils/StringHelper.h"
+#include "ZFile.h"
+#include "ZRoom/ZRoom.h"
+
+SetMinimapList::SetMinimapList(ZFile* nParent) : ZRoomCommand(nParent)
+{
+}
+
+void SetMinimapList::ParseRawData()
+{
+	ZRoomCommand::ParseRawData();
+	listSegmentAddr = BitConverter::ToInt32BE(parent->GetRawData(), segmentOffset);
+	listSegmentOffset = GETSEGOFFSET(listSegmentAddr);
+	unk4 = BitConverter::ToInt32BE(parent->GetRawData(), segmentOffset + 4);
+
+	uint32_t currentPtr = listSegmentOffset;
+
+	minimaps.reserve(zRoom->roomCount);
+	for (int32_t i = 0; i < zRoom->roomCount; i++)
+	{
+		MinimapEntry entry(parent->GetRawData(), currentPtr);
+		minimaps.push_back(entry);
+
+		currentPtr += 10;
+	}
+}
+
+void SetMinimapList::DeclareReferences(const std::string& prefix)
+{
+	{
+		std::string declaration;
+
+		size_t index = 0;
+		for (const auto& entry : minimaps)
+		{
+			declaration += StringHelper::Sprintf("    { %s },", entry.GetBodySourceCode().c_str());
+
+			if (index < minimaps.size() - 1)
+				declaration += "\n";
+
+			index++;
+		}
+
+		parent->AddDeclarationArray(
+			listSegmentOffset, DeclarationAlignment::Align4, minimaps.size() * 10, "MinimapEntry",
+			StringHelper::Sprintf("%sMinimapEntryList0x%06X", prefix.c_str(), listSegmentOffset),
+			minimaps.size(), declaration);
+	}
+
+	{
+		std::string listName;
+		Globals::Instance->GetSegmentedPtrName(listSegmentAddr, parent, "MinimapEntry", listName,
+		                                       parent->workerID);
+		std::string declaration = StringHelper::Sprintf("\n\t%s, 0x%08X\n", listName.c_str(), unk4);
+
+		parent->AddDeclaration(
+			segmentOffset, DeclarationAlignment::Align4, 8, "MinimapList",
+			StringHelper::Sprintf("%sMinimapList0x%06X", prefix.c_str(), segmentOffset),
+			declaration);
+	}
+}
+
+std::string SetMinimapList::GetBodySourceCode() const
+{
+	std::string listName;
+	Globals::Instance->GetSegmentedPtrName(cmdArg2, parent, "MinimapList", listName,
+	                                       parent->workerID);
+	return StringHelper::Sprintf("SCENE_CMD_MINIMAP_INFO(%s)", listName.c_str());
+}
+
+std::string SetMinimapList::GetCommandCName() const
+{
+	return "SCmdMinimapSettings";
+}
+
+RoomCommand SetMinimapList::GetRoomCommand() const
+{
+	return RoomCommand::SetMinimapList;
+}
+
+MinimapEntry::MinimapEntry(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex)
+	: unk0(BitConverter::ToUInt16BE(rawData, rawDataIndex + 0)),
+	  unk2(BitConverter::ToUInt16BE(rawData, rawDataIndex + 2)),
+	  unk4(BitConverter::ToUInt16BE(rawData, rawDataIndex + 4)),
+	  unk6(BitConverter::ToUInt16BE(rawData, rawDataIndex + 6)),
+	  unk8(BitConverter::ToUInt16BE(rawData, rawDataIndex + 8))
+{
+}
+
+std::string MinimapEntry::GetBodySourceCode() const
+{
+	return StringHelper::Sprintf("0x%04X, 0x%04X, 0x%04X, 0x%04X, 0x%04X", unk0, unk2, unk4, unk6,
+	                             unk8);
+}

ZAPDTR/ZAPD/ZRoom/Commands/SetMinimapList.h

@@ -0,0 +1,39 @@
+#pragma once
+
+#include "ZRoom/ZRoomCommand.h"
+
+class MinimapEntry
+{
+public:
+	MinimapEntry(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex);
+
+	std::string GetBodySourceCode() const;
+
+protected:
+	uint16_t unk0;
+	uint16_t unk2;
+	uint16_t unk4;
+	uint16_t unk6;
+	uint16_t unk8;
+};
+
+class SetMinimapList : public ZRoomCommand
+{
+public:
+	std::vector<MinimapEntry> minimaps;
+
+	SetMinimapList(ZFile* nParent);
+
+	void ParseRawData() override;
+	void DeclareReferences(const std::string& prefix) override;
+
+	std::string GetBodySourceCode() const override;
+
+	RoomCommand GetRoomCommand() const override;
+	std::string GetCommandCName() const override;
+
+private:
+	segptr_t listSegmentAddr;
+	uint32_t listSegmentOffset;
+	uint32_t unk4;
+};

ZAPDTR/ZAPD/ZRoom/Commands/SetObjectList.cpp

@@ -0,0 +1,67 @@
+#include "SetObjectList.h"
+
+#include "Globals.h"
+#include "Utils/BitConverter.h"
+#include "Utils/StringHelper.h"
+#include "ZFile.h"
+#include "ZRoom/ZNames.h"
+#include "ZRoom/ZRoom.h"
+
+SetObjectList::SetObjectList(ZFile* nParent) : ZRoomCommand(nParent)
+{
+}
+
+void SetObjectList::ParseRawData()
+{
+	ZRoomCommand::ParseRawData();
+	uint8_t objectCnt = parent->GetRawData().at(rawDataIndex + 1);
+	uint32_t currentPtr = segmentOffset;
+
+	objects.reserve(objectCnt);
+	for (uint8_t i = 0; i < objectCnt; i++)
+	{
+		uint16_t objectIndex = BitConverter::ToInt16BE(parent->GetRawData(), currentPtr);
+		objects.push_back(objectIndex);
+		currentPtr += 2;
+	}
+}
+
+void SetObjectList::DeclareReferences(const std::string& prefix)
+{
+	if (!objects.empty())
+	{
+		std::string declaration;
+
+		for (size_t i = 0; i < objects.size(); i++)
+		{
+			uint16_t objectIndex = objects[i];
+			declaration +=
+				StringHelper::Sprintf("    %s,", ZNames::GetObjectName(objectIndex).c_str());
+
+			if (i < objects.size() - 1)
+				declaration += "\n";
+		}
+
+		parent->AddDeclarationArray(
+			segmentOffset, DeclarationAlignment::Align4, objects.size() * 2, "s16",
+			StringHelper::Sprintf("%sObjectList_%06X", prefix.c_str(), segmentOffset),
+			objects.size(), declaration);
+	}
+}
+
+std::string SetObjectList::GetBodySourceCode() const
+{
+	std::string listName;
+	Globals::Instance->GetSegmentedPtrName(cmdArg2, parent, "s16", listName, parent->workerID);
+	return StringHelper::Sprintf("SCENE_CMD_OBJECT_LIST(%i, %s)", objects.size(), listName.c_str());
+}
+
+std::string SetObjectList::GetCommandCName() const
+{
+	return "SCmdObjectList";
+}
+
+RoomCommand SetObjectList::GetRoomCommand() const
+{
+	return RoomCommand::SetObjectList;
+}

ZAPDTR/ZAPD/ZRoom/Commands/SetObjectList.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "ZRoom/ZRoomCommand.h"
+
+class SetObjectList : public ZRoomCommand
+{
+public:
+	std::vector<uint16_t> objects;
+
+	SetObjectList(ZFile* nParent);
+
+	void ParseRawData() override;
+	void DeclareReferences(const std::string& prefix) override;
+
+	std::string GetBodySourceCode() const override;
+
+	std::string GetCommandCName() const override;
+	RoomCommand GetRoomCommand() const override;
+};

ZAPDTR/ZAPD/ZRoom/Commands/SetPathways.cpp

@@ -0,0 +1,65 @@
+#include "SetPathways.h"
+
+#include "Globals.h"
+#include "Utils/BitConverter.h"
+#include "Utils/StringHelper.h"
+#include "ZFile.h"
+#include "ZRoom/ZRoom.h"
+
+SetPathways::SetPathways(ZFile* nParent) : ZRoomCommand(nParent), pathwayList(nParent)
+{
+}
+
+void SetPathways::DeclareReferences([[maybe_unused]] const std::string& prefix)
+{
+	if (segmentOffset != 0)
+	{
+		std::string varName =
+			StringHelper::Sprintf("%sPathway_%06X", prefix.c_str(), segmentOffset);
+		parent->AddDeclarationPlaceholder(segmentOffset, varName);
+	}
+}
+
+void SetPathways::ParseRawDataLate()
+{
+	if (Globals::Instance->game == ZGame::MM_RETAIL)
+	{
+		auto numPaths = zRoom->GetDeclarationSizeFromNeighbor(segmentOffset) / 8;
+		pathwayList.SetNumPaths(numPaths);
+	}
+
+	if (Globals::Instance->otrMode)
+	{
+		auto zPath = (ZPath*)parent->FindResource(segmentOffset);
+		
+		if (zPath != nullptr)
+			pathwayList = *zPath;
+	}
+
+	pathwayList.ExtractFromFile(segmentOffset);
+}
+
+void SetPathways::DeclareReferencesLate(const std::string& prefix)
+{
+	std::string varName = StringHelper::Sprintf("%sPathway_%06X", prefix.c_str(), segmentOffset);
+	pathwayList.SetName(varName);
+	pathwayList.DeclareReferences(prefix);
+	pathwayList.GetSourceOutputCode(prefix);
+}
+
+std::string SetPathways::GetBodySourceCode() const
+{
+	std::string listName;
+	Globals::Instance->GetSegmentedPtrName(cmdArg2, parent, "Path", listName, parent->workerID);
+	return StringHelper::Sprintf("SCENE_CMD_PATH_LIST(%s)", listName.c_str());
+}
+
+std::string SetPathways::GetCommandCName() const
+{
+	return "SCmdPathList";
+}
+
+RoomCommand SetPathways::GetRoomCommand() const
+{
+	return RoomCommand::SetPathways;
+}

ZAPDTR/ZAPD/ZRoom/Commands/SetPathways.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include "ZPath.h"
+#include "ZResource.h"
+#include "ZRoom/ZRoomCommand.h"
+
+class SetPathways : public ZRoomCommand
+{
+public:
+	ZPath pathwayList;
+
+	SetPathways(ZFile* nParent);
+
+	void DeclareReferences(const std::string& prefix) override;
+
+	void ParseRawDataLate() override;
+	void DeclareReferencesLate(const std::string& prefix) override;
+
+	std::string GetBodySourceCode() const override;
+
+	RoomCommand GetRoomCommand() const override;
+	std::string GetCommandCName() const override;
+};

ZAPDTR/ZAPD/ZRoom/Commands/SetRoomBehavior.cpp

@@ -0,0 +1,50 @@
+#include "SetRoomBehavior.h"
+
+#include "Globals.h"
+#include "Utils/BitConverter.h"
+#include "Utils/StringHelper.h"
+
+SetRoomBehavior::SetRoomBehavior(ZFile* nParent) : ZRoomCommand(nParent)
+{
+}
+
+void SetRoomBehavior::ParseRawData()
+{
+	ZRoomCommand::ParseRawData();
+	gameplayFlags = cmdArg1;
+	gameplayFlags2 = BitConverter::ToInt32BE(parent->GetRawData(), rawDataIndex + 0x04);
+
+	currRoomUnk2 = gameplayFlags2 & 0xFF;
+
+	currRoomUnk5 = showInvisActors = (gameplayFlags2 >> 8) & 1;
+
+	msgCtxUnk = (gameplayFlags2 >> 10) & 1;
+
+	enablePosLights = (gameplayFlags2 >> 11) & 1;
+	kankyoContextUnkE2 = (gameplayFlags2 >> 12) & 1;
+}
+
+std::string SetRoomBehavior::GetBodySourceCode() const
+{
+	if (Globals::Instance->game == ZGame::MM_RETAIL)
+	{
+		std::string enableLights = StringHelper::BoolStr(enablePosLights);
+		return StringHelper::Sprintf("SCENE_CMD_ROOM_BEHAVIOR(0x%02X, 0x%02X, %i, %i, %s, %i)",
+		                             gameplayFlags, currRoomUnk2, currRoomUnk5, msgCtxUnk,
+		                             enableLights.c_str(), kankyoContextUnkE2);
+	}
+	std::string showInvisible = StringHelper::BoolStr(showInvisActors);
+	std::string disableWarps = StringHelper::BoolStr(msgCtxUnk);
+	return StringHelper::Sprintf("SCENE_CMD_ROOM_BEHAVIOR(0x%02X, 0x%02X, %s, %s)", gameplayFlags,
+	                             currRoomUnk2, showInvisible.c_str(), disableWarps.c_str());
+}
+
+std::string SetRoomBehavior::GetCommandCName() const
+{
+	return "SCmdRoomBehavior";
+}
+
+RoomCommand SetRoomBehavior::GetRoomCommand() const
+{
+	return RoomCommand::SetRoomBehavior;
+}

ZAPDTR/ZAPD/ZRoom/Commands/SetRoomBehavior.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "ZRoom/ZRoomCommand.h"
+
+class SetRoomBehavior : public ZRoomCommand
+{
+public:
+	uint8_t gameplayFlags;
+	uint32_t gameplayFlags2;
+
+	uint8_t currRoomUnk2;
+
+	uint8_t showInvisActors;
+	uint8_t currRoomUnk5;
+
+	uint8_t msgCtxUnk;
+
+	uint8_t enablePosLights;
+	uint8_t kankyoContextUnkE2;
+
+	SetRoomBehavior(ZFile* nParent);
+
+	void ParseRawData() override;
+
+	std::string GetBodySourceCode() const override;
+
+	RoomCommand GetRoomCommand() const override;
+	std::string GetCommandCName() const override;
+};

ZAPDTR/ZAPD/ZRoom/Commands/SetRoomList.cpp

@@ -0,0 +1,155 @@
+#include "SetRoomList.h"
+
+#include "Globals.h"
+#include "Utils/BitConverter.h"
+#include "Utils/StringHelper.h"
+#include "ZFile.h"
+#include "ZRoom/ZRoom.h"
+
+SetRoomList::SetRoomList(ZFile* nParent) : ZRoomCommand(nParent)
+{
+}
+
+void SetRoomList::ParseRawData()
+{
+	ZRoomCommand::ParseRawData();
+	int numRooms = cmdArg1;
+
+	romfile = new RomFile(parent);
+	romfile->numRooms = numRooms;
+	romfile->ExtractFromFile(segmentOffset);
+
+	parent->resources.push_back(romfile);
+
+	zRoom->roomCount = numRooms;
+}
+
+void SetRoomList::DeclareReferences(const std::string& prefix)
+{
+	ZRoomCommand::DeclareReferences(prefix);
+
+	romfile->DeclareVar(prefix, "");
+}
+
+std::string SetRoomList::GetBodySourceCode() const
+{
+	std::string listName;
+	Globals::Instance->GetSegmentedPtrName(cmdArg2, parent, "RomFile", listName, parent->workerID);
+	return StringHelper::Sprintf("SCENE_CMD_ROOM_LIST(%i, %s)", romfile->rooms.size(),
+	                             listName.c_str());
+}
+
+std::string SetRoomList::GetCommandCName() const
+{
+	return "SCmdRoomList";
+}
+
+RoomCommand SetRoomList::GetRoomCommand() const
+{
+	return RoomCommand::SetRoomList;
+}
+
+RomFile::RomFile(ZFile* nParent) : ZResource(nParent)
+{
+}
+
+void RomFile::ParseXML(tinyxml2::XMLElement* reader)
+{
+	ZResource::ParseXML(reader);
+
+	if (reader->Attribute("NumRooms") != nullptr)
+	{
+		numRooms = StringHelper::StrToL(std::string(reader->Attribute("NumRooms")));
+	}
+}
+
+void RomFile::ParseRawData()
+{
+	ZResource::ParseRawData();
+
+	uint32_t currentPtr = rawDataIndex;
+
+	rooms.reserve(numRooms);
+	for (int32_t i = 0; i < numRooms; i++)
+	{
+		RoomEntry entry(parent->GetRawData(), currentPtr);
+		rooms.push_back(entry);
+
+		currentPtr += 8;
+	}
+}
+
+Declaration* RomFile::DeclareVar(const std::string& prefix, const std::string& body)
+{
+	std::string auxName = name;
+	if (name == "")
+		auxName = StringHelper::Sprintf("%sRoomList0x%06X", prefix.c_str(), rawDataIndex);
+
+	return parent->AddDeclarationArray(rawDataIndex, DeclarationAlignment::Align4,
+	                                   rooms.size() * rooms.at(0).GetRawDataSize(),
+	                                   GetSourceTypeName(), auxName, rooms.size(), body);
+}
+
+std::string RomFile::GetBodySourceCode() const
+{
+	std::string declaration;
+	bool isFirst = true;
+
+	for (ZFile* file : Globals::Instance->files)
+	{
+		for (ZResource* res : file->resources)
+		{
+			if (res->GetResourceType() == ZResourceType::Room)
+			{
+				std::string roomName = res->GetName();
+				if (!isFirst)
+					declaration += "\n";
+
+				declaration += StringHelper::Sprintf(
+					"\t{ (uintptr_t)_%sSegmentRomStart, (uintptr_t)_%sSegmentRomEnd },",
+					roomName.c_str(), roomName.c_str());
+				isFirst = false;
+			}
+		}
+	}
+
+	return declaration;
+}
+
+void RomFile::GetSourceOutputCode(const std::string& prefix)
+{
+	DeclareVar(prefix, GetBodySourceCode());
+}
+
+std::string RomFile::GetSourceTypeName() const
+{
+	return "RomFile";
+}
+
+ZResourceType RomFile::GetResourceType() const
+{
+	// TODO
+	return ZResourceType::Error;
+}
+
+size_t RomFile::GetRawDataSize() const
+{
+	return 8 * rooms.size();
+}
+
+RoomEntry::RoomEntry(uint32_t nVAS, uint32_t nVAE)
+{
+	virtualAddressStart = nVAS;
+	virtualAddressEnd = nVAE;
+}
+
+RoomEntry::RoomEntry(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex)
+	: RoomEntry(BitConverter::ToInt32BE(rawData, rawDataIndex + 0),
+                BitConverter::ToInt32BE(rawData, rawDataIndex + 4))
+{
+}
+
+size_t RoomEntry::GetRawDataSize() const
+{
+	return 0x08;
+}

ZAPDTR/ZAPD/ZRoom/Commands/SetRoomList.h

@@ -0,0 +1,53 @@
+#pragma once
+
+#include "ZRoom/ZRoomCommand.h"
+
+class RoomEntry
+{
+public:
+	int32_t virtualAddressStart;
+	int32_t virtualAddressEnd;
+
+	RoomEntry(uint32_t nVAS, uint32_t nVAE);
+	RoomEntry(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex);
+
+	size_t GetRawDataSize() const;
+};
+
+class RomFile : public ZResource
+{
+public:
+	RomFile(ZFile* nParent);
+
+	void ParseXML(tinyxml2::XMLElement* reader) override;
+	void ParseRawData() override;
+
+	Declaration* DeclareVar(const std::string& prefix, const std::string& body) override;
+	std::string GetBodySourceCode() const override;
+	void GetSourceOutputCode(const std::string& prefix) override;
+
+	std::string GetSourceTypeName() const override;
+	virtual ZResourceType GetResourceType() const override;
+
+	virtual size_t GetRawDataSize() const override;
+
+	uint8_t numRooms = 0;
+	std::vector<RoomEntry> rooms;
+};
+
+class SetRoomList : public ZRoomCommand
+{
+public:
+	// Borrowed reference. Don't delete.
+	RomFile* romfile = nullptr;
+
+	SetRoomList(ZFile* nParent);
+
+	void ParseRawData() override;
+	void DeclareReferences(const std::string& prefix) override;
+
+	std::string GetBodySourceCode() const override;
+
+	RoomCommand GetRoomCommand() const override;
+	std::string GetCommandCName() const override;
+};

ZAPDTR/ZAPD/ZRoom/Commands/SetSkyboxModifier.cpp

@@ -0,0 +1,32 @@
+#include "SetSkyboxModifier.h"
+
+#include "Utils/StringHelper.h"
+
+SetSkyboxModifier::SetSkyboxModifier(ZFile* nParent) : ZRoomCommand(nParent)
+{
+}
+
+void SetSkyboxModifier::ParseRawData()
+{
+	ZRoomCommand::ParseRawData();
+	disableSky = parent->GetRawData().at(rawDataIndex + 0x04);
+	disableSunMoon = parent->GetRawData().at(rawDataIndex + 0x05);
+}
+
+std::string SetSkyboxModifier::GetBodySourceCode() const
+{
+	std::string sky = StringHelper::BoolStr(disableSky);
+	std::string soonMoon = StringHelper::BoolStr(disableSunMoon);
+	return StringHelper::Sprintf("SCENE_CMD_SKYBOX_DISABLES(%s, %s)", sky.c_str(),
+	                             soonMoon.c_str());
+}
+
+std::string SetSkyboxModifier::GetCommandCName() const
+{
+	return "SCmdSkyboxDisables";
+}
+
+RoomCommand SetSkyboxModifier::GetRoomCommand() const
+{
+	return RoomCommand::SetSkyboxModifier;
+}

ZAPDTR/ZAPD/ZRoom/Commands/SetSkyboxModifier.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "ZRoom/ZRoomCommand.h"
+
+class SetSkyboxModifier : public ZRoomCommand
+{
+public:
+	uint8_t disableSky;
+	uint8_t disableSunMoon;
+
+	SetSkyboxModifier(ZFile* nParent);
+
+	void ParseRawData() override;
+
+	std::string GetBodySourceCode() const override;
+
+	std::string GetCommandCName() const override;
+	RoomCommand GetRoomCommand() const override;
+};

ZAPDTR/ZAPD/ZRoom/Commands/SetSkyboxSettings.cpp

@@ -0,0 +1,36 @@
+#include "SetSkyboxSettings.h"
+#include "Globals.h"
+#include "Utils/StringHelper.h"
+
+SetSkyboxSettings::SetSkyboxSettings(ZFile* nParent) : ZRoomCommand(nParent)
+{
+}
+
+void SetSkyboxSettings::ParseRawData()
+{
+	ZRoomCommand::ParseRawData();
+	unk1 = cmdArg1;
+	skyboxNumber = parent->GetRawData().at(rawDataIndex + 0x04);
+	cloudsType = parent->GetRawData().at(rawDataIndex + 0x05);
+	isIndoors = parent->GetRawData().at(rawDataIndex + 0x06);
+}
+
+std::string SetSkyboxSettings::GetBodySourceCode() const
+{
+	std::string indoors = StringHelper::BoolStr(isIndoors);
+	if (Globals::Instance->game == ZGame::MM_RETAIL)
+		return StringHelper::Sprintf("SCENE_CMD_SKYBOX_SETTINGS(0x%02X, %i, %i, %s)", unk1,
+		                             skyboxNumber, cloudsType, indoors.c_str());
+	return StringHelper::Sprintf("SCENE_CMD_SKYBOX_SETTINGS(%i, %i, %s)", skyboxNumber, cloudsType,
+	                             indoors.c_str());
+}
+
+std::string SetSkyboxSettings::GetCommandCName() const
+{
+	return "SCmdSkyboxSettings";
+}
+
+RoomCommand SetSkyboxSettings::GetRoomCommand() const
+{
+	return RoomCommand::SetSkyboxSettings;
+}

ZAPDTR/ZAPD/ZRoom/Commands/SetSkyboxSettings.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "ZRoom/ZRoomCommand.h"
+
+class SetSkyboxSettings : public ZRoomCommand
+{
+public:
+	uint8_t unk1;  // (MM Only)
+	uint8_t skyboxNumber;
+	uint8_t cloudsType;
+	uint8_t isIndoors;
+
+	SetSkyboxSettings(ZFile* nParent);
+
+	void ParseRawData() override;
+
+	std::string GetBodySourceCode() const override;
+
+	std::string GetCommandCName() const override;
+	RoomCommand GetRoomCommand() const override;
+};

ZAPDTR/ZAPD/ZRoom/Commands/SetSoundSettings.cpp

@@ -0,0 +1,30 @@
+#include "SetSoundSettings.h"
+#include "Utils/StringHelper.h"
+
+SetSoundSettings::SetSoundSettings(ZFile* nParent) : ZRoomCommand(nParent)
+{
+}
+
+void SetSoundSettings::ParseRawData()
+{
+	ZRoomCommand::ParseRawData();
+	reverb = cmdArg1;
+	nightTimeSFX = parent->GetRawData().at(rawDataIndex + 0x06);
+	musicSequence = parent->GetRawData().at(rawDataIndex + 0x07);
+}
+
+std::string SetSoundSettings::GetBodySourceCode() const
+{
+	return StringHelper::Sprintf("SCENE_CMD_SOUND_SETTINGS(%i, %i, %i)", reverb, nightTimeSFX,
+	                             musicSequence);
+}
+
+std::string SetSoundSettings::GetCommandCName() const
+{
+	return "SCmdSoundSettings";
+}
+
+RoomCommand SetSoundSettings::GetRoomCommand() const
+{
+	return RoomCommand::SetSoundSettings;
+}

ZAPDTR/ZAPD/ZRoom/Commands/SetSoundSettings.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include "ZRoom/ZRoomCommand.h"
+
+class SetSoundSettings : public ZRoomCommand
+{
+public:
+	uint8_t reverb;
+	uint8_t nightTimeSFX;
+	uint8_t musicSequence;
+
+	SetSoundSettings(ZFile* nParent);
+
+	void ParseRawData() override;
+
+	std::string GetBodySourceCode() const override;
+
+	RoomCommand GetRoomCommand() const override;
+	std::string GetCommandCName() const override;
+};

ZAPDTR/ZAPD/ZRoom/Commands/SetSpecialObjects.cpp

@@ -0,0 +1,34 @@
+#include "SetSpecialObjects.h"
+
+#include "Utils/BitConverter.h"
+#include "Utils/StringHelper.h"
+#include "ZRoom/ZNames.h"
+
+SetSpecialObjects::SetSpecialObjects(ZFile* nParent) : ZRoomCommand(nParent)
+{
+}
+
+void SetSpecialObjects::ParseRawData()
+{
+	ZRoomCommand::ParseRawData();
+	elfMessage = cmdArg1;
+	globalObject = BitConverter::ToUInt16BE(parent->GetRawData(), rawDataIndex + 0x06);
+}
+
+std::string SetSpecialObjects::GetBodySourceCode() const
+{
+	std::string objectName = ZNames::GetObjectName(globalObject);
+
+	return StringHelper::Sprintf("SCENE_CMD_SPECIAL_FILES(0x%02X, %s)", elfMessage,
+	                             objectName.c_str());
+}
+
+std::string SetSpecialObjects::GetCommandCName() const
+{
+	return "SCmdSpecialFiles";
+}
+
+RoomCommand SetSpecialObjects::GetRoomCommand() const
+{
+	return RoomCommand::SetSpecialObjects;
+}

ZAPDTR/ZAPD/ZRoom/Commands/SetSpecialObjects.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "ZRoom/ZRoomCommand.h"
+
+class SetSpecialObjects : public ZRoomCommand
+{
+public:
+	uint8_t elfMessage;
+	uint16_t globalObject;
+
+	SetSpecialObjects(ZFile* nParent);
+
+	void ParseRawData() override;
+
+	std::string GetBodySourceCode() const override;
+
+	RoomCommand GetRoomCommand() const override;
+	std::string GetCommandCName() const override;
+};

ZAPDTR/ZAPD/ZRoom/Commands/SetStartPositionList.cpp

@@ -0,0 +1,68 @@
+#include "SetStartPositionList.h"
+
+#include "Globals.h"
+#include "Utils/BitConverter.h"
+#include "Utils/StringHelper.h"
+#include "ZFile.h"
+#include "ZRoom/ZNames.h"
+#include "ZRoom/ZRoom.h"
+
+SetStartPositionList::SetStartPositionList(ZFile* nParent) : ZRoomCommand(nParent)
+{
+}
+
+void SetStartPositionList::ParseRawData()
+{
+	ZRoomCommand::ParseRawData();
+	uint8_t numActors = cmdArg1;
+
+	offset_t currentPtr = segmentOffset;
+
+	actors.reserve(numActors);
+	for (uint32_t i = 0; i < numActors; i++)
+	{
+		actors.push_back(ActorSpawnEntry(parent->GetRawData(), currentPtr));
+		currentPtr += 16;
+	}
+}
+
+void SetStartPositionList::DeclareReferences(const std::string& prefix)
+{
+	if (!actors.empty())
+	{
+		std::string declaration;
+
+		size_t index = 0;
+		for (const auto& entry : actors)
+		{
+			declaration += StringHelper::Sprintf("    { %s },", entry.GetBodySourceCode().c_str());
+			if (index + 1 < actors.size())
+				declaration += "\n";
+
+			index++;
+		}
+
+		parent->AddDeclarationArray(
+			segmentOffset, DeclarationAlignment::Align4, actors.size() * 16, "ActorEntry",
+			StringHelper::Sprintf("%sStartPositionList0x%06X", prefix.c_str(), segmentOffset),
+			actors.size(), declaration);
+	}
+}
+
+std::string SetStartPositionList::GetBodySourceCode() const
+{
+	std::string listName;
+	Globals::Instance->GetSegmentedPtrName(cmdArg2, parent, "ActorEntry", listName,
+	                                       parent->workerID);
+	return StringHelper::Sprintf("SCENE_CMD_SPAWN_LIST(%i, %s)", actors.size(), listName.c_str());
+}
+
+std::string SetStartPositionList::GetCommandCName() const
+{
+	return "SCmdSpawnList";
+}
+
+RoomCommand SetStartPositionList::GetRoomCommand() const
+{
+	return RoomCommand::SetStartPositionList;
+}

ZAPDTR/ZAPD/ZRoom/Commands/SetStartPositionList.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include "SetActorList.h"
+#include "ZRoom/ZRoomCommand.h"
+
+class SetStartPositionList : public ZRoomCommand
+{
+public:
+	std::vector<ActorSpawnEntry> actors;
+
+	SetStartPositionList(ZFile* nParent);
+
+	void ParseRawData() override;
+	void DeclareReferences(const std::string& prefix) override;
+
+	std::string GetBodySourceCode() const override;
+
+	RoomCommand GetRoomCommand() const override;
+	std::string GetCommandCName() const override;
+};

ZAPDTR/ZAPD/ZRoom/Commands/SetTimeSettings.cpp

@@ -0,0 +1,30 @@
+#include "SetTimeSettings.h"
+#include "Utils/BitConverter.h"
+#include "Utils/StringHelper.h"
+
+SetTimeSettings::SetTimeSettings(ZFile* nParent) : ZRoomCommand(nParent)
+{
+}
+
+void SetTimeSettings::ParseRawData()
+{
+	ZRoomCommand::ParseRawData();
+	hour = parent->GetRawData().at(rawDataIndex + 4);
+	min = parent->GetRawData().at(rawDataIndex + 5);
+	unk = parent->GetRawData().at(rawDataIndex + 6);
+}
+
+std::string SetTimeSettings::GetBodySourceCode() const
+{
+	return StringHelper::Sprintf("SCENE_CMD_TIME_SETTINGS(%i, %i, %i)", hour, min, unk);
+}
+
+std::string SetTimeSettings::GetCommandCName() const
+{
+	return "SCmdTimeSettings";
+}
+
+RoomCommand SetTimeSettings::GetRoomCommand() const
+{
+	return RoomCommand::SetTimeSettings;
+}

ZAPDTR/ZAPD/ZRoom/Commands/SetTimeSettings.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include "ZRoom/ZRoomCommand.h"
+
+class SetTimeSettings : public ZRoomCommand
+{
+public:
+	uint8_t hour;
+	uint8_t min;
+	uint8_t unk;
+
+	SetTimeSettings(ZFile* nParent);
+
+	void ParseRawData() override;
+
+	std::string GetBodySourceCode() const override;
+
+	std::string GetCommandCName() const override;
+	RoomCommand GetRoomCommand() const override;
+};

ZAPDTR/ZAPD/ZRoom/Commands/SetTransitionActorList.cpp

@@ -0,0 +1,93 @@
+#include "SetTransitionActorList.h"
+
+#include "Globals.h"
+#include "Utils/BitConverter.h"
+#include "Utils/StringHelper.h"
+#include "ZFile.h"
+#include "ZRoom/ZNames.h"
+#include "ZRoom/ZRoom.h"
+
+SetTransitionActorList::SetTransitionActorList(ZFile* nParent) : ZRoomCommand(nParent)
+{
+}
+
+void SetTransitionActorList::ParseRawData()
+{
+	ZRoomCommand::ParseRawData();
+	int numActors = cmdArg1;
+	uint32_t currentPtr = segmentOffset;
+
+	transitionActors.reserve(numActors);
+	for (int32_t i = 0; i < numActors; i++)
+	{
+		TransitionActorEntry entry(parent->GetRawData(), currentPtr);
+		transitionActors.push_back(entry);
+
+		currentPtr += 16;
+	}
+}
+
+void SetTransitionActorList::DeclareReferences(const std::string& prefix)
+{
+	std::string declaration;
+
+	size_t index = 0;
+	for (const auto& entry : transitionActors)
+	{
+		declaration += StringHelper::Sprintf("    { %s },", entry.GetBodySourceCode().c_str());
+		if (index + 1 < transitionActors.size())
+		{
+			declaration += "\n";
+		}
+
+		index++;
+	}
+
+	parent->AddDeclarationArray(
+		segmentOffset, DeclarationAlignment::Align4, transitionActors.size() * 16,
+		"TransitionActorEntry",
+		StringHelper::Sprintf("%sTransitionActorList_%06X", prefix.c_str(), segmentOffset),
+		transitionActors.size(), declaration);
+}
+
+std::string SetTransitionActorList::GetBodySourceCode() const
+{
+	std::string listName;
+	Globals::Instance->GetSegmentedPtrName(cmdArg2, parent, "TransitionActorEntry", listName,
+	                                       parent->workerID);
+	return StringHelper::Sprintf("SCENE_CMD_TRANSITION_ACTOR_LIST(%i, %s)", transitionActors.size(),
+	                             listName.c_str());
+}
+
+std::string SetTransitionActorList::GetCommandCName() const
+{
+	return "SCmdTransiActorList";
+}
+
+RoomCommand SetTransitionActorList::GetRoomCommand() const
+{
+	return RoomCommand::SetTransitionActorList;
+}
+
+TransitionActorEntry::TransitionActorEntry(const std::vector<uint8_t>& rawData, int rawDataIndex)
+{
+	frontObjectRoom = rawData[rawDataIndex + 0];
+	frontTransitionReaction = rawData[rawDataIndex + 1];
+	backObjectRoom = rawData[rawDataIndex + 2];
+	backTransitionReaction = rawData[rawDataIndex + 3];
+	actorNum = BitConverter::ToInt16BE(rawData, rawDataIndex + 4);
+	posX = BitConverter::ToInt16BE(rawData, rawDataIndex + 6);
+	posY = BitConverter::ToInt16BE(rawData, rawDataIndex + 8);
+	posZ = BitConverter::ToInt16BE(rawData, rawDataIndex + 10);
+	rotY = BitConverter::ToInt16BE(rawData, rawDataIndex + 12);
+	initVar = BitConverter::ToInt16BE(rawData, rawDataIndex + 14);
+}
+
+std::string TransitionActorEntry::GetBodySourceCode() const
+{
+	std::string actorStr = ZNames::GetActorName(actorNum);
+
+	return StringHelper::Sprintf("%i, %i, %i, %i, %s, %i, %i, %i, %i, 0x%04X", frontObjectRoom,
+	                             frontTransitionReaction, backObjectRoom, backTransitionReaction,
+	                             actorStr.c_str(), posX, posY, posZ, rotY, initVar);
+}

ZAPDTR/ZAPD/ZRoom/Commands/SetTransitionActorList.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include "ZRoom/ZRoomCommand.h"
+
+class TransitionActorEntry
+{
+public:
+	uint8_t frontObjectRoom;
+	uint8_t frontTransitionReaction;
+	uint8_t backObjectRoom;
+	uint8_t backTransitionReaction;
+	uint16_t actorNum;
+	int16_t posX, posY, posZ;
+	int16_t rotY;
+	uint16_t initVar;
+
+	TransitionActorEntry(const std::vector<uint8_t>& rawData, int rawDataIndex);
+
+	std::string GetBodySourceCode() const;
+};
+
+class SetTransitionActorList : public ZRoomCommand
+{
+public:
+	std::vector<TransitionActorEntry> transitionActors;
+
+	SetTransitionActorList(ZFile* nParent);
+
+	void ParseRawData() override;
+	void DeclareReferences(const std::string& prefix) override;
+
+	std::string GetBodySourceCode() const override;
+
+	RoomCommand GetRoomCommand() const override;
+	std::string GetCommandCName() const override;
+};

ZAPDTR/ZAPD/ZRoom/Commands/SetWind.cpp

@@ -0,0 +1,32 @@
+#include "SetWind.h"
+#include "Utils/StringHelper.h"
+
+SetWind::SetWind(ZFile* nParent) : ZRoomCommand(nParent)
+{
+}
+
+void SetWind::ParseRawData()
+{
+	ZRoomCommand::ParseRawData();
+	auto& parentRawData = parent->GetRawData();
+	windWest = parentRawData.at(rawDataIndex + 0x04);
+	windVertical = parentRawData.at(rawDataIndex + 0x05);
+	windSouth = parentRawData.at(rawDataIndex + 0x06);
+	clothFlappingStrength = parentRawData.at(rawDataIndex + 0x07);
+}
+
+std::string SetWind::GetBodySourceCode() const
+{
+	return StringHelper::Sprintf("SCENE_CMD_WIND_SETTINGS(%i, %i, %i, %i)", windWest, windVertical,
+	                             windSouth, clothFlappingStrength);
+}
+
+std::string SetWind::GetCommandCName() const
+{
+	return "SCmdWindSettings";
+}
+
+RoomCommand SetWind::GetRoomCommand() const
+{
+	return RoomCommand::SetWind;
+}

ZAPDTR/ZAPD/ZRoom/Commands/SetWind.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "ZRoom/ZRoomCommand.h"
+
+class SetWind : public ZRoomCommand
+{
+public:
+	uint8_t windWest;
+	uint8_t windVertical;
+	uint8_t windSouth;
+	uint8_t clothFlappingStrength;
+
+	SetWind(ZFile* nParent);
+
+	void ParseRawData() override;
+
+	std::string GetBodySourceCode() const override;
+
+	std::string GetCommandCName() const override;
+	RoomCommand GetRoomCommand() const override;
+};

ZAPDTR/ZAPD/ZRoom/Commands/SetWorldMapVisited.cpp

@@ -0,0 +1,22 @@
+#include "SetWorldMapVisited.h"
+
+#include "Utils/StringHelper.h"
+
+SetWorldMapVisited::SetWorldMapVisited(ZFile* nParent) : ZRoomCommand(nParent)
+{
+}
+
+std::string SetWorldMapVisited::GetBodySourceCode() const
+{
+	return "SCENE_CMD_MISC_SETTINGS()";
+}
+
+std::string SetWorldMapVisited::GetCommandCName() const
+{
+	return "SCmdWorldMapVisited";
+}
+
+RoomCommand SetWorldMapVisited::GetRoomCommand() const
+{
+	return RoomCommand::SetWorldMapVisited;
+}

ZAPDTR/ZAPD/ZRoom/Commands/SetWorldMapVisited.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "ZRoom/ZRoomCommand.h"
+
+class SetWorldMapVisited : public ZRoomCommand
+{
+public:
+	SetWorldMapVisited(ZFile* nParent);
+
+	std::string GetBodySourceCode() const override;
+
+	RoomCommand GetRoomCommand() const override;
+	std::string GetCommandCName() const override;
+};

ZAPDTR/ZAPD/ZRoom/Commands/Unused09.cpp

@@ -0,0 +1,21 @@
+#include "Unused09.h"
+#include "Utils/StringHelper.h"
+
+Unused09::Unused09(ZFile* nParent) : ZRoomCommand(nParent)
+{
+}
+
+std::string Unused09::GetBodySourceCode() const
+{
+	return "SCENE_CMD_UNK_09()";
+}
+
+std::string Unused09::GetCommandCName() const
+{
+	return "SceneCmd";
+}
+
+RoomCommand Unused09::GetRoomCommand() const
+{
+	return RoomCommand::Unused09;
+}

ZAPDTR/ZAPD/ZRoom/Commands/Unused09.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "ZRoom/ZRoomCommand.h"
+
+class Unused09 : public ZRoomCommand
+{
+public:
+	Unused09(ZFile* nParent);
+
+	std::string GetBodySourceCode() const override;
+
+	RoomCommand GetRoomCommand() const override;
+	std::string GetCommandCName() const override;
+};

ZAPDTR/ZAPD/ZRoom/Commands/Unused1D.cpp

@@ -0,0 +1,21 @@
+#include "Unused1D.h"
+#include "Utils/StringHelper.h"
+
+Unused1D::Unused1D(ZFile* nParent) : ZRoomCommand(nParent)
+{
+}
+
+std::string Unused1D::GetBodySourceCode() const
+{
+	return StringHelper::Sprintf("{ %s, 0x00, 0x00 }", GetCommandHex().c_str());
+}
+
+std::string Unused1D::GetCommandCName() const
+{
+	return "SceneCmd";
+}
+
+RoomCommand Unused1D::GetRoomCommand() const
+{
+	return RoomCommand::Unused1D;
+}

ZAPDTR/ZAPD/ZRoom/Commands/Unused1D.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "ZRoom/ZRoomCommand.h"
+
+class Unused1D : public ZRoomCommand
+{
+public:
+	Unused1D(ZFile* nParent);
+
+	std::string GetBodySourceCode() const override;
+
+	RoomCommand GetRoomCommand() const override;
+	std::string GetCommandCName() const override;
+};

ZAPDTR/ZAPD/ZRoom/Commands/ZRoomCommandUnk.cpp

@@ -0,0 +1,20 @@
+#include "ZRoomCommandUnk.h"
+#include "Utils/BitConverter.h"
+#include "Utils/StringHelper.h"
+#include "ZRoom/ZRoom.h"
+
+ZRoomCommandUnk::ZRoomCommandUnk(ZFile* nParent) : ZRoomCommand(nParent)
+{
+}
+
+std::string ZRoomCommandUnk::GetBodySourceCode() const
+{
+	return StringHelper::Sprintf("{ %s, 0x%02X, 0x%06X } /* WARNING: "
+	                             "UNIMPLEMENTED ROOM COMMAND */",
+	                             GetCommandHex().c_str(), cmdArg1, cmdArg2);
+}
+
+RoomCommand ZRoomCommandUnk::GetRoomCommand() const
+{
+	return RoomCommand::Error;
+}

ZAPDTR/ZAPD/ZRoom/Commands/ZRoomCommandUnk.h

@@ -0,0 +1,12 @@
+#pragma once
+#include "ZRoom/ZRoomCommand.h"
+
+class ZRoomCommandUnk : public ZRoomCommand
+{
+public:
+	ZRoomCommandUnk(ZFile* nParent);
+
+	std::string GetBodySourceCode() const override;
+
+	RoomCommand GetRoomCommand() const override;
+};