mirror of
https://github.com/zeldaret/oot.git
synced 2025-02-04 02:44:24 +00:00
4e55168eaa
* git subrepo pull --force tools/ZAPD subrepo: subdir: "tools/ZAPD" merged: "094e79734" upstream: origin: "https://github.com/zeldaret/ZAPD.git" branch: "master" commit: "094e79734" git-subrepo: version: "0.4.6" origin: "https://github.com/ingydotnet/git-subrepo" commit: "110b9eb" * Add EnumData.xml where some names are now externalized * Remove legacy typedefs for zapd, no longer needed!
413 lines
13 KiB
C++
413 lines
13 KiB
C++
#include "ZCollision.h"
|
|
#include "ZWaterbox.h"
|
|
|
|
#include <cassert>
|
|
#include <cstdint>
|
|
#include <string>
|
|
|
|
#include "Globals.h"
|
|
#include "Utils/BitConverter.h"
|
|
#include "Utils/StringHelper.h"
|
|
|
|
REGISTER_ZFILENODE(Collision, ZCollisionHeader);
|
|
|
|
ZCollisionHeader::ZCollisionHeader(ZFile* nParent) : ZResource(nParent)
|
|
{
|
|
}
|
|
|
|
ZCollisionHeader::~ZCollisionHeader()
|
|
{
|
|
delete camData;
|
|
}
|
|
|
|
void ZCollisionHeader::ParseRawData()
|
|
{
|
|
const auto& rawData = parent->GetRawData();
|
|
|
|
absMinX = BitConverter::ToInt16BE(rawData, rawDataIndex + 0);
|
|
absMinY = BitConverter::ToInt16BE(rawData, rawDataIndex + 2);
|
|
absMinZ = BitConverter::ToInt16BE(rawData, rawDataIndex + 4);
|
|
|
|
absMaxX = BitConverter::ToInt16BE(rawData, rawDataIndex + 6);
|
|
absMaxY = BitConverter::ToInt16BE(rawData, rawDataIndex + 8);
|
|
absMaxZ = BitConverter::ToInt16BE(rawData, rawDataIndex + 10);
|
|
|
|
numVerts = BitConverter::ToUInt16BE(rawData, rawDataIndex + 12);
|
|
vtxAddress = BitConverter::ToInt32BE(rawData, rawDataIndex + 16);
|
|
|
|
numPolygons = BitConverter::ToUInt16BE(rawData, rawDataIndex + 20);
|
|
polyAddress = BitConverter::ToInt32BE(rawData, rawDataIndex + 24);
|
|
polyTypeDefAddress = BitConverter::ToInt32BE(rawData, rawDataIndex + 28);
|
|
camDataAddress = BitConverter::ToInt32BE(rawData, rawDataIndex + 32);
|
|
|
|
numWaterBoxes = BitConverter::ToUInt16BE(rawData, rawDataIndex + 36);
|
|
waterBoxAddress = BitConverter::ToInt32BE(rawData, rawDataIndex + 40);
|
|
|
|
vtxSegmentOffset = Seg2Filespace(vtxAddress, parent->baseAddress);
|
|
polySegmentOffset = Seg2Filespace(polyAddress, parent->baseAddress);
|
|
polyTypeDefSegmentOffset = Seg2Filespace(polyTypeDefAddress, parent->baseAddress);
|
|
camDataSegmentOffset = Seg2Filespace(camDataAddress, parent->baseAddress);
|
|
waterBoxSegmentOffset = Seg2Filespace(waterBoxAddress, parent->baseAddress);
|
|
|
|
vertices.reserve(numVerts);
|
|
polygons.reserve(numPolygons);
|
|
waterBoxes.reserve(numWaterBoxes);
|
|
|
|
offset_t currentPtr = vtxSegmentOffset;
|
|
|
|
for (uint16_t i = 0; i < numVerts; i++)
|
|
{
|
|
ZVector vec(parent);
|
|
vec.ExtractFromBinary(currentPtr, ZScalarType::ZSCALAR_S16, 3);
|
|
|
|
currentPtr += vec.GetRawDataSize();
|
|
vertices.push_back(vec);
|
|
}
|
|
|
|
for (uint16_t i = 0; i < numPolygons; i++)
|
|
{
|
|
ZCollisionPoly poly(parent);
|
|
poly.SetRawDataIndex(polySegmentOffset + (i * 16));
|
|
poly.ParseRawData();
|
|
polygons.push_back(poly);
|
|
}
|
|
|
|
uint16_t highestPolyType = 0;
|
|
|
|
for (const ZCollisionPoly& poly : polygons)
|
|
{
|
|
if (poly.type > highestPolyType)
|
|
highestPolyType = poly.type;
|
|
}
|
|
|
|
for (uint16_t i = 0; i < highestPolyType + 1; i++)
|
|
{
|
|
ZSurfaceType surfaceType(parent);
|
|
surfaceType.SetRawDataIndex(polyTypeDefSegmentOffset + (i * 8));
|
|
surfaceType.ParseRawData();
|
|
polygonTypes.push_back(surfaceType);
|
|
}
|
|
// polygonTypes.push_back(
|
|
// BitConverter::ToUInt64BE(rawData, polyTypeDefSegmentOffset + (i * 8)));
|
|
|
|
if (camDataAddress != SEGMENTED_NULL)
|
|
{
|
|
// Try to guess how many elements the CamDataList array has.
|
|
// The "guessing algorithm" is basically a "best effort" one and it
|
|
// is error-prone.
|
|
// This is based mostly on observation of how CollisionHeader data is
|
|
// usually ordered. If for some reason the data was in some other funny
|
|
// order, this would probably break.
|
|
// The most common ordering is:
|
|
// - *BgCamInfo*
|
|
// - SurfaceType
|
|
// - CollisionPoly
|
|
// - Vertices
|
|
// - WaterBoxes
|
|
// - CollisionHeader
|
|
offset_t upperCameraBoundary = polyTypeDefSegmentOffset;
|
|
if (upperCameraBoundary == SEGMENTED_NULL)
|
|
{
|
|
upperCameraBoundary = polySegmentOffset;
|
|
}
|
|
if (upperCameraBoundary == SEGMENTED_NULL)
|
|
{
|
|
upperCameraBoundary = vtxSegmentOffset;
|
|
}
|
|
if (upperCameraBoundary == SEGMENTED_NULL)
|
|
{
|
|
upperCameraBoundary = waterBoxSegmentOffset;
|
|
}
|
|
if (upperCameraBoundary == SEGMENTED_NULL)
|
|
{
|
|
upperCameraBoundary = rawDataIndex;
|
|
}
|
|
|
|
// Sharp Ocarina places the CamDataEntries above the list so we need to calculate the number
|
|
// of cameras differently.
|
|
if (upperCameraBoundary < camDataSegmentOffset)
|
|
{
|
|
offset_t offset = camDataSegmentOffset;
|
|
while (rawData[offset] == 0x00 && rawData[offset + 0x4] == 0x02)
|
|
{
|
|
offset += 0x08;
|
|
}
|
|
upperCameraBoundary = offset;
|
|
}
|
|
|
|
camData =
|
|
new CameraDataList(parent, name, rawData, camDataSegmentOffset, upperCameraBoundary);
|
|
}
|
|
|
|
for (int32_t i = 0; i < numWaterBoxes; i++)
|
|
{
|
|
ZWaterbox waterbox(parent);
|
|
|
|
waterbox.SetRawDataIndex(waterBoxSegmentOffset +
|
|
(i * (Globals::Instance->game == ZGame::OOT_SW97 ? 12 : 16)));
|
|
waterbox.ParseRawData();
|
|
waterBoxes.emplace_back(waterbox);
|
|
}
|
|
}
|
|
|
|
void ZCollisionHeader::DeclareReferences(const std::string& prefix)
|
|
{
|
|
std::string declaration = "";
|
|
std::string auxName = name;
|
|
|
|
if (name == "")
|
|
auxName = GetDefaultName(prefix);
|
|
|
|
if (waterBoxes.size() > 0)
|
|
{
|
|
for (size_t i = 0; i < waterBoxes.size(); i++)
|
|
{
|
|
declaration +=
|
|
StringHelper::Sprintf("\t{ %s },", waterBoxes[i].GetBodySourceCode().c_str());
|
|
if (i + 1 < waterBoxes.size())
|
|
declaration += "\n";
|
|
}
|
|
|
|
parent->AddDeclarationArray(waterBoxSegmentOffset, DeclarationAlignment::Align4,
|
|
waterBoxes[0].GetRawDataSize() * waterBoxes.size(),
|
|
waterBoxes[0].GetSourceTypeName().c_str(),
|
|
StringHelper::Sprintf("%sWaterBoxes", auxName.c_str()),
|
|
waterBoxes.size(), declaration);
|
|
}
|
|
|
|
if (polygons.size() > 0)
|
|
{
|
|
declaration.clear();
|
|
|
|
for (size_t i = 0; i < polygons.size(); i++)
|
|
{
|
|
declaration += StringHelper::Sprintf("\t%s,", polygons[i].GetBodySourceCode().c_str());
|
|
if (i + 1 < polygons.size())
|
|
declaration += "\n";
|
|
}
|
|
|
|
parent->AddDeclarationArray(polySegmentOffset, DeclarationAlignment::Align4,
|
|
polygons.size() * 16, polygons[0].GetSourceTypeName().c_str(),
|
|
StringHelper::Sprintf("%sPolygons", auxName.c_str()),
|
|
polygons.size(), declaration);
|
|
}
|
|
|
|
declaration.clear();
|
|
for (const auto& polyType : polygonTypes)
|
|
{
|
|
declaration += StringHelper::Sprintf("\t%s,", polyType.GetBodySourceCode().c_str());
|
|
}
|
|
|
|
if (polyTypeDefAddress != SEGMENTED_NULL)
|
|
parent->AddDeclarationArray(polyTypeDefSegmentOffset, DeclarationAlignment::Align4,
|
|
polygonTypes.size() * 8,
|
|
polygonTypes[0].GetSourceTypeName().c_str(),
|
|
StringHelper::Sprintf("%sSurfaceType", auxName.c_str()),
|
|
polygonTypes.size(), declaration);
|
|
|
|
declaration.clear();
|
|
|
|
if (vertices.size() > 0)
|
|
{
|
|
declaration.clear();
|
|
|
|
for (size_t i = 0; i < vertices.size(); i++)
|
|
{
|
|
declaration +=
|
|
StringHelper::Sprintf("\t{ %s },", vertices[i].GetBodySourceCode().c_str());
|
|
|
|
if (i < vertices.size() - 1)
|
|
declaration += "\n";
|
|
}
|
|
|
|
const auto& first = vertices.front();
|
|
if (vtxAddress != 0)
|
|
parent->AddDeclarationArray(
|
|
vtxSegmentOffset, first.GetDeclarationAlignment(),
|
|
vertices.size() * first.GetRawDataSize(), first.GetSourceTypeName(),
|
|
StringHelper::Sprintf("%sVertices", auxName.c_str()), vertices.size(), declaration);
|
|
}
|
|
}
|
|
|
|
std::string ZCollisionHeader::GetBodySourceCode() const
|
|
{
|
|
std::string declaration = "";
|
|
|
|
declaration += "\n";
|
|
|
|
declaration += StringHelper::Sprintf("\t{ %i, %i, %i },\n", absMinX, absMinY, absMinZ);
|
|
declaration += StringHelper::Sprintf("\t{ %i, %i, %i },\n", absMaxX, absMaxY, absMaxZ);
|
|
|
|
std::string vtxName;
|
|
Globals::Instance->GetSegmentedPtrName(vtxAddress, parent, "Vec3s", vtxName);
|
|
|
|
if (numVerts > 0)
|
|
declaration +=
|
|
StringHelper::Sprintf("\tARRAY_COUNT(%s), %s,\n", vtxName.c_str(), vtxName.c_str());
|
|
else
|
|
declaration += StringHelper::Sprintf("\t%i, %s,\n", numVerts, vtxName.c_str());
|
|
|
|
std::string polyName;
|
|
Globals::Instance->GetSegmentedPtrName(polyAddress, parent, "CollisionPoly", polyName);
|
|
|
|
if (numPolygons > 0)
|
|
declaration +=
|
|
StringHelper::Sprintf("\tARRAY_COUNT(%s), %s,\n", polyName.c_str(), polyName.c_str());
|
|
else
|
|
declaration += StringHelper::Sprintf("\t%i, %s,\n", numPolygons, polyName.c_str());
|
|
|
|
std::string surfaceName;
|
|
Globals::Instance->GetSegmentedPtrName(polyTypeDefAddress, parent, "SurfaceType", surfaceName);
|
|
declaration += StringHelper::Sprintf("\t%s,\n", surfaceName.c_str());
|
|
|
|
std::string camName;
|
|
Globals::Instance->GetSegmentedPtrName(camDataAddress, parent, "BgCamInfo", camName);
|
|
declaration += StringHelper::Sprintf("\t%s,\n", camName.c_str());
|
|
|
|
std::string waterBoxName;
|
|
Globals::Instance->GetSegmentedPtrName(waterBoxAddress, parent, "WaterBox", waterBoxName);
|
|
|
|
if (numWaterBoxes > 0)
|
|
declaration += StringHelper::Sprintf("\tARRAY_COUNT(%s), %s\n", waterBoxName.c_str(),
|
|
waterBoxName.c_str());
|
|
else
|
|
declaration += StringHelper::Sprintf("\t%i, %s\n", numWaterBoxes, waterBoxName.c_str());
|
|
|
|
return declaration;
|
|
}
|
|
|
|
std::string ZCollisionHeader::GetDefaultName(const std::string& prefix) const
|
|
{
|
|
return StringHelper::Sprintf("%sCol_%06X", prefix.c_str(), rawDataIndex);
|
|
}
|
|
|
|
std::string ZCollisionHeader::GetSourceTypeName() const
|
|
{
|
|
return "CollisionHeader";
|
|
}
|
|
|
|
ZResourceType ZCollisionHeader::GetResourceType() const
|
|
{
|
|
return ZResourceType::CollisionHeader;
|
|
}
|
|
|
|
size_t ZCollisionHeader::GetRawDataSize() const
|
|
{
|
|
return 44;
|
|
}
|
|
|
|
CameraDataList::CameraDataList(ZFile* parent, const std::string& prefix,
|
|
const std::vector<uint8_t>& rawData, offset_t rawDataIndex,
|
|
offset_t upperCameraBoundary)
|
|
{
|
|
std::string declaration;
|
|
|
|
// Parse CameraDataEntries
|
|
size_t numElements = (upperCameraBoundary - rawDataIndex) / 8;
|
|
assert(numElements < 10000);
|
|
|
|
offset_t cameraPosDataSeg = rawDataIndex;
|
|
uint32_t numDataTotal;
|
|
uint32_t cameraPosDataSegEnd = rawDataIndex;
|
|
bool isSharpOcarina = false;
|
|
|
|
for (size_t i = 0; i < numElements; i++)
|
|
{
|
|
CameraDataEntry entry;
|
|
|
|
entry.cameraSType =
|
|
BitConverter::ToInt16BE(rawData, rawDataIndex + (entries.size() * 8) + 0);
|
|
entry.numData = BitConverter::ToInt16BE(rawData, rawDataIndex + (entries.size() * 8) + 2);
|
|
entry.cameraPosDataSeg =
|
|
BitConverter::ToInt32BE(rawData, rawDataIndex + (entries.size() * 8) + 4);
|
|
|
|
if (entry.cameraPosDataSeg != 0 && GETSEGNUM(entry.cameraPosDataSeg) != SEGMENT_SCENE)
|
|
{
|
|
cameraPosDataSeg = rawDataIndex + (entries.size() * 8);
|
|
break;
|
|
}
|
|
|
|
if (rawDataIndex > GETSEGOFFSET(entry.cameraPosDataSeg))
|
|
{
|
|
if (entry.cameraPosDataSeg != 0 &&
|
|
cameraPosDataSeg > GETSEGOFFSET(entry.cameraPosDataSeg))
|
|
cameraPosDataSeg = GETSEGOFFSET(entry.cameraPosDataSeg);
|
|
}
|
|
else
|
|
{
|
|
// Sharp Ocarina will place the cam data after the list as opposed to the original maps
|
|
// which have it before.
|
|
isSharpOcarina = true;
|
|
cameraPosDataSeg = rawDataIndex + (numElements * 0x8);
|
|
if (cameraPosDataSegEnd < GETSEGOFFSET(entry.cameraPosDataSeg))
|
|
cameraPosDataSegEnd = GETSEGOFFSET(entry.cameraPosDataSeg);
|
|
}
|
|
|
|
entries.emplace_back(entry);
|
|
}
|
|
|
|
// Setting cameraPosDataAddr to rawDataIndex give a pos list length of 0
|
|
uint32_t cameraPosDataOffset = GETSEGOFFSET(cameraPosDataSeg);
|
|
for (size_t i = 0; i < entries.size(); i++)
|
|
{
|
|
char camSegLine[2048];
|
|
|
|
if (entries[i].cameraPosDataSeg != 0)
|
|
{
|
|
uint32_t index =
|
|
(GETSEGOFFSET(entries[i].cameraPosDataSeg) - cameraPosDataOffset) / 0x6;
|
|
snprintf(camSegLine, 2048, "&%sCamPosData[%i]", prefix.c_str(), index);
|
|
}
|
|
else
|
|
snprintf(camSegLine, 2048, "NULL");
|
|
|
|
declaration +=
|
|
StringHelper::Sprintf(" { 0x%04X, %i, %s },", entries[i].cameraSType,
|
|
entries[i].numData, camSegLine, rawDataIndex + (i * 8));
|
|
|
|
if (i < entries.size() - 1)
|
|
declaration += "\n";
|
|
}
|
|
|
|
parent->AddDeclarationArray(
|
|
rawDataIndex, DeclarationAlignment::Align4, entries.size() * 8, "BgCamInfo",
|
|
StringHelper::Sprintf("%sCamDataList", prefix.c_str(), rawDataIndex), entries.size(),
|
|
declaration);
|
|
|
|
if (!isSharpOcarina)
|
|
numDataTotal = (rawDataIndex - cameraPosDataOffset) / 0x6;
|
|
else
|
|
numDataTotal = ((cameraPosDataSegEnd - cameraPosDataSeg) + 18) / 0x6;
|
|
|
|
if (numDataTotal > 0)
|
|
{
|
|
declaration.clear();
|
|
cameraPositionData.reserve(numDataTotal);
|
|
for (uint32_t i = 0; i < numDataTotal; i++)
|
|
{
|
|
CameraPositionData data = CameraPositionData(rawData, cameraPosDataOffset + (i * 6));
|
|
|
|
declaration += StringHelper::Sprintf("\t{ %6i, %6i, %6i },", data.x, data.y, data.z);
|
|
cameraPositionData.emplace_back(data);
|
|
if (i + 1 < numDataTotal)
|
|
declaration += "\n";
|
|
}
|
|
|
|
uint32_t cameraPosDataIndex = GETSEGOFFSET(cameraPosDataSeg);
|
|
uint32_t entrySize = numDataTotal * 0x6;
|
|
parent->AddDeclarationArray(cameraPosDataIndex, DeclarationAlignment::Align4, entrySize,
|
|
"Vec3s", StringHelper::Sprintf("%sCamPosData", prefix.c_str()),
|
|
numDataTotal, declaration);
|
|
}
|
|
}
|
|
|
|
CameraDataList::~CameraDataList()
|
|
{
|
|
}
|
|
|
|
CameraPositionData::CameraPositionData(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex)
|
|
{
|
|
x = BitConverter::ToInt16BE(rawData, rawDataIndex + 0);
|
|
y = BitConverter::ToInt16BE(rawData, rawDataIndex + 2);
|
|
z = BitConverter::ToInt16BE(rawData, rawDataIndex + 4);
|
|
}
|