void CRWSection_Texture::unserialize(void)
{
CDataReader *pDataReader = CDataReader::getInstance();
m_usFilterFlags = pDataReader->readUint16();
m_usUnknown1 = pDataReader->readUint16();
}
void CRWSection_Clump::unserialize(void)
{
CDataReader *pDataReader = CDataReader::getInstance();
/*
todo
if (m_pParentNode == pDFFFile) // found first clump struct in the DFF file
{
setSectionHeaderSkipped(false);
pLatestClump = pClump;
m_pParentNode = pClump;
}
else
{
setSectionHeaderSkipped(true);
}
*/
m_uiAtomicallyLinkedObjectCount = pDataReader->readUint32();
//if ((uiRWVersionId >= 0x0C02FFFF || uiRWVersionId == 0x0400CFFF) ////////// && uiRWVersionId != 0x1003FFFF ////////)
if (m_uiSectionSize == 12)
{
m_uiLightCount = pDataReader->readUint32();
m_uiCameraCount = pDataReader->readUint32();
}
else
{
m_uiLightCount = 1;
m_uiCameraCount = 1;
}
}
void CBMPFormat::unserializeVersion4(void)
{
CDataReader *pDataReader = CDataReader::getInstance();
uint32 uiByteCount;
// read headers 1 & 2
CBMPFormat_Header1 *pHeader1 = pDataReader->readStruct<CBMPFormat_Header1>();
CBMPFormat_Header2_Version4 *pHeader2 = pDataReader->readStruct<CBMPFormat_Header2_Version4>();
// palette
m_bHasPalette = pHeader2->m_usBPP < 16;
if (m_bHasPalette)
{
uiByteCount = 4 * pHeader2->m_uiColoursUsed;
m_strPaletteData = pDataReader->readString(uiByteCount);
}
// raster data
uiByteCount = pHeader2->m_uiWidth * pHeader2->m_uiHeight * ((float32)pHeader2->m_usBPP / 8.0f);
m_strRasterData = pDataReader->readString(uiByteCount);
// copy from raw structs to wrapper structs
m_uiWidth = pHeader2->m_uiWidth;
m_uiHeight = pHeader2->m_uiHeight;
m_usColourPlaneCount = pHeader2->m_usPlaneCount;
m_usBPP = pHeader2->m_usBPP;
// clean up
delete pHeader1;
delete pHeader2;
}
void CCOLEntry::parseCollisionMeshVertices(void)
{
CDataReader *pDataReader = CDataReader::getInstance();
eCOLVersion eCOLVersionValue = getCOLVersion() == nullptr ? COL_UNKNOWN : getCOLVersion()->getVersionId();
vector<TVertex>& vecVertices = getCollisionMeshVertices();
for (uint32 i = 0, j = getCollisionMeshVertexCount(); i < j; i++)
{
char szText1[500];
TVertex vertex;
if (eCOLVersionValue == COL_1)
{
vertex.m_x = pDataReader->readFloat32();
vertex.m_y = pDataReader->readFloat32();
vertex.m_z = pDataReader->readFloat32();
}
else
{
vertex.m_x = ((float32) pDataReader->readInt16()) / 128.0f;
vertex.m_y = ((float32) pDataReader->readInt16()) / 128.0f;
vertex.m_z = ((float32) pDataReader->readInt16()) / 128.0f;
}
vecVertices.push_back(vertex);
}
}
void CDATLoaderFormat::unserialize(void)
{
CDataReader *pDataReader = CDataReader::getInstance();
pDataReader->readAndStoreLines();
while (pDataReader->iterateLines())
{
unserializeLine();
}
}
void CLocalizationFormat::unserializeLine(void)
{
CDataReader *pDataReader = CDataReader::getInstance();
string strLine = *pDataReader->getActiveLine();
strLine = CStringUtility::trim(strLine, " ");
strLine = CStringUtility::trim(strLine, "\t");
if (strLine == "")
{
// blank line
return;
}
else if (strLine.c_str()[0] == '#')
{
// comment line
return;
}
else
{
// remove comment from end of line
string strComment = "";
size_t uiCommentPosition = strLine.find('#');
if (uiCommentPosition != string::npos)
{
strComment = strLine.substr(uiCommentPosition + 1);
strLine = strLine.substr(0, uiCommentPosition);
}
uint32 uiFirstCommaPosition = strLine.find(',');
if (uiFirstCommaPosition == string::npos)
{
// line does not have comma
return;
}
string strInternalName = strLine.substr(0, uiFirstCommaPosition);
string strLanguageText = strLine.substr(uiFirstCommaPosition + 1);
strInternalName = CStringUtility::trim(strInternalName, " ");
strInternalName = CStringUtility::trim(strInternalName, "\t");
strLanguageText = CStringUtility::trim(strLanguageText, " ");
strLanguageText = CStringUtility::trim(strLanguageText, "\t");
if (strLanguageText == "")
{
// line does not have language text set
return;
}
m_umapTranslatedText[strInternalName] = strLanguageText;
}
}
void CLocalizationFormat::unserialize(void)
{
CDataReader *pDataReader = CDataReader::getInstance();
pDataReader->readAndStoreLines();
while (pDataReader->iterateLines())
{
unserializeLine();
}
pDataReader->resetLines();
}
uint32 CCOLEntry::calculateShadowMeshVertexCount(void)
{
CDataReader *pDataReader = CDataReader::getInstance();
eCOLVersion eCOLVersionValue = getCOLVersion() == nullptr ? COL_UNKNOWN : getCOLVersion()->getVersionId();
//CDebugger::log("getHeaderStartOffset(): " + CStringUtility::toString(getHeaderStartOffset()));
//CDebugger::log("getShadowMeshFacesOffset(): " + CStringUtility::toString(getShadowMeshFacesOffset()));
//CDebugger::log("getShadowMeshFaceCount(): " + CStringUtility::toString(getShadowMeshFaceCount()));
//CDebugger::log("getCOLVersion(): " + CStringUtility::toString(getCOLVersion()));
pDataReader->setSeek(getHeaderStartOffset() + 4 + getShadowMeshFacesOffset());
string strShadowMeshFacesData = pDataReader->readString(getShadowMeshFaceCount() * (eCOLVersionValue == 1 ? 16 : 8)); // 12 or 6 = sizeof(TVertex)
//CDebugger::log("part 2 -- strShadowMeshFacesData.length(): " + CStringUtility::toString(strShadowMeshFacesData.length()));
uint32 uiSeek = 0;
uint32 uiHighestVertexIndex = 0;
if (getShadowMeshFaceCount() == 0)
{
return 0;
}
if (eCOLVersionValue == COL_1)
{
// COL 1
for (uint32 i = 0, j = getShadowMeshFaceCount(); i < j; i++)
{
for (uint8 i2 = 0; i2 < 3; i2++)
{
uint32 uiVertexIndex = CStringUtility::unpackUint32(strShadowMeshFacesData.substr(uiSeek, 4), false);
if (uiVertexIndex > uiHighestVertexIndex)
{
uiHighestVertexIndex = uiVertexIndex;
}
uiSeek += 4; // 4 is sizeof(uint32)
}
uiSeek += 4; // 4 is sizeof(TSurface)
}
}
else
{
// COL 2, 3 & 4
for (uint32 i = 0, j = getShadowMeshFaceCount(); i < j; i++)
{
for (uint8 i2 = 0; i2 < 3; i2++)
{
uint32 uiVertexIndex = CStringUtility::unpackUint16(strShadowMeshFacesData.substr(uiSeek, 2), false);
if (uiVertexIndex > uiHighestVertexIndex)
{
uiHighestVertexIndex = uiVertexIndex;
}
uiSeek += 2; // 2 is sizeof(uint16)
}
uiSeek += 2; // 1 byte for material, 1 byte for light
}
}
return uiHighestVertexIndex + 1;
}
void CIDEEntry_2DFX_Ladder::unserialize(void)
{
CDataReader *pDataReader = CDataReader::getInstance();
CIDEEntry_2DFX::unserialize();
m_vecLadderStartPosition = pDataReader->readVector3D();
m_vecLadderEndPosition = pDataReader->readVector3D();
m_vecClimbDirectionPosition = pDataReader->readVector3D();
m_uiFlags = pDataReader->readTokenUint32();
}
void CIDEEntry_2DFX_SpawnPoint::unserialize(void)
{
CDataReader *pDataReader = CDataReader::getInstance();
CIDEEntry_2DFX::unserialize();
m_vecFlags.m_x = pDataReader->readTokenUint32();
m_vecFlags.m_y = pDataReader->readTokenUint32();
m_vecFlags.m_z = pDataReader->readTokenUint32();
m_vecFlags.m_w = pDataReader->readTokenUint32();
}
void CCOLEntry::parseShadowMeshVertices(void)
{
CDataReader *pDataReader = CDataReader::getInstance();
vector<TVertex>& vecVertices = getShadowMeshVertices();
for (uint32 i = 0, j = getShadowMeshVertexCount(); i < j; i++)
{
TVertex vertex;
vertex.m_x = ((float32) pDataReader->readInt16()) / 128.0f;
vertex.m_y = ((float32) pDataReader->readInt16()) / 128.0f;
vertex.m_z = ((float32) pDataReader->readInt16()) / 128.0f;
vecVertices.push_back(vertex);
}
}
void CIDEEntry_PATH_Node::unserialize(void)
{
CDataReader *pDataReader = CDataReader::getInstance();
if (getLatestPathGroup() == nullptr)
{
// path node found before path group
throw EXCEPTION_INVALID_DATA_ORDER;
}
switch (pDataReader->getLineTokens().size())
{
case 9:
CIDEEntry_PATH::unserialize();
setFormatType(0);
setFormatGames(GAME_FLAG_GTA_III | GAME_FLAG_GTA_VC);
m_uiNodeType = pDataReader->readTokenUint32();
m_uiNextNode = pDataReader->readTokenUint32();
m_uiIsCrossRoad = pDataReader->readTokenUint32();
m_vecPosition = pDataReader->readVector3D() / 16.0f;
m_fUnknown1 = pDataReader->readTokenFloat32();
m_uiLeftLaneCount = pDataReader->readTokenUint32();
m_uiRightLaneCount = pDataReader->readTokenUint32();
break;
}
getLatestPathGroup()->addEntry(this);
}
void CIPLEntry_PICK::unserialize(void)
{
CDataReader *pDataReader = CDataReader::getInstance();
switch (pDataReader->getLineTokens().size())
{
case 4:
setFormatType(0);
setFormatGames(GAME_FLAG_GTA_SA);
m_uiWeaponId = pDataReader->readTokenUint32();
m_vecPosition = pDataReader->readTokenVector3D();
break;
default:
throw EXCEPTION_UNKNOWN_FORMAT_TYPE;
}
}
uint8 CBMPFormat::detectBMPVersion(void)
{
CDataReader *pDataReader = CDataReader::getInstance();
uint8 uiBMPVersion = 0;
pDataReader->setPeek(true);
string strHeader = pDataReader->readString(2);
if (strHeader.c_str()[0] == '\0' && strHeader.c_str()[1] == '\0')
{
// BMP version 1.x
uiBMPVersion = 1;
}
else if (strHeader.c_str()[0] == 'B' && strHeader.c_str()[1] == 'M')
{
// BMP version 2.x, 3.x or 4.x
pDataReader->setSeek(12);
switch (pDataReader->readUint32())
{
case 12: // BMP version 2.x
uiBMPVersion = 2;
break;
case 40: // BMP version 3.x
uiBMPVersion = 3;
break;
case 108: // BMP version 4.x
uiBMPVersion = 4;
}
}
pDataReader->setPeek(false);
pDataReader->setSeek(0);
return uiBMPVersion;
}
void CCOLEntry::parseShadowMeshFaces(void)
{
CDataReader *pDataReader = CDataReader::getInstance();
vector<TFace>& vecFaces = getShadowMeshFaces();
for (uint32 i = 0, j = getShadowMeshFaceCount(); i < j; i++)
{
TFace face;
face.m_uiA = pDataReader->readUint16();
face.m_uiB = pDataReader->readUint16();
face.m_uiC = pDataReader->readUint16();
face.m_surface.m_ucMaterial = pDataReader->readUint8();
face.m_surface.m_ucFlag = 0;
face.m_surface.m_ucBrightness = 0;
face.m_surface.m_ucLight = pDataReader->readUint8();
vecFaces.push_back(face);
}
}
void CIDEEntry_HIER::unserialize(void)
{
CDataReader *pDataReader = CDataReader::getInstance();
switch (pDataReader->getLineTokens().size())
{
case 3:
// GTA III, GTA VC, GTA SA
setFormatType(0);
setFormatGames(GAME_FLAG_GTA_III | GAME_FLAG_GTA_VC | GAME_FLAG_GTA_SA);
m_uiObjectId = pDataReader->readTokenUint32();
m_strModelName = pDataReader->readTokenString();
m_strTXDName = pDataReader->readTokenString();
break;
default:
throw EXCEPTION_UNKNOWN_FORMAT_TYPE;
}
}
void CIDEEntry_PATH_Group::unserialize(void)
{
CDataReader *pDataReader = CDataReader::getInstance();
switch (pDataReader->getLineTokens().size())
{
case 3:
CIDEEntry_PATH::unserialize();
setFormatType(0);
setFormatGames(GAME_FLAG_GTA_III | GAME_FLAG_GTA_VC);
m_strGroupType = pDataReader->readTokenString();
m_uiObjectId = pDataReader->readTokenUint32();
m_strModelName = pDataReader->readTokenUint32();
break;
}
setLatestPathGroup(this);
}
void CDBEntry::unserialize(void)
{
CDataReader *pDataReader = CDataReader::getInstance();
uint32 uiEntryNameLength = pDataReader->readUint32();
m_strEntryName = string((char*)pDataReader->readCString(uiEntryNameLength));
m_uiEntrySize = pDataReader->readUint32();
m_uiEntryDataCRC = pDataReader->readUint32();
m_uiEntryCreationDate = pDataReader->readUint32();
m_bHasIssue = (pDataReader->readUint8() & 1) == 1;
}
void CDDSFormat::unserialize(void)
{
CDataReader *pDataReader = CDataReader::getInstance();
// file header
uint32 uiMagicNumber = pDataReader->readUint32(); // 0x20534444
// DDS_HEADER structure
CDDSFormat_Header_DDS_HEADER *pHeader1 = pDataReader->readStruct<CDDSFormat_Header_DDS_HEADER>();
// DDS_PIXELFORMAT structure
CDDSFormat_Header_DDS_PIXELFORMAT_Part1 *pHeader2 = pDataReader->readStruct<CDDSFormat_Header_DDS_PIXELFORMAT_Part1>();
if (pHeader2->m_uiFlags2 == 4/*DDPF_FOURCC*/ && string((char*)&pHeader2->m_ucFourCC, 4) == "DX10")
{
// DDS_HEADER_DXT10 structure
CDDSFormat_Header_DDS_HEADER_DXT10 *pHeader3 = pDataReader->readStruct<CDDSFormat_Header_DDS_HEADER_DXT10>();
delete pHeader3;
}
// DDS_HEADER structure continued
CDDSFormat_Header_DDS_PIXELFORMAT_Part2 *pHeader4 = pDataReader->readStruct<CDDSFormat_Header_DDS_PIXELFORMAT_Part2>();
// raster data
m_strRasterData = pDataReader->readString(pHeader1->m_uiWidth * pHeader1->m_uiHeight * (pHeader2->m_uiRGBBitCount / 8));
// copy from raw structs to wrapper structs
m_uiWidth = pHeader1->m_uiWidth;
m_uiHeight = pHeader1->m_uiHeight;
m_uiBPP = pHeader2->m_uiRGBBitCount / 8;
// clean up
delete pHeader1;
delete pHeader2;
delete pHeader4;
}
void CDATLoaderFormat::unserializeLine(void)
{
CDataReader *pDataReader = CDataReader::getInstance();
string strLine = *pDataReader->getActiveLine();
// remove comment from end of line
string strComment = "";
size_t uiCommentPosition = strLine.find('#');
if (uiCommentPosition != string::npos)
{
strComment = strLine.substr(uiCommentPosition);
strLine = strLine.substr(0, uiCommentPosition);
}
if (strLine == "")
{
// blank line
}
else if (CStringUtility::ltrim(strLine).c_str()[0] == '#')
{
// line is a comment
}
else
{
// parse line
deque<string> deqTokens = CVectorUtility::convertVectorToDeque(CStringUtility::split(strLine, " "));
CDATLoaderEntry *pDATLoaderEntry = new CDATLoaderEntry;
pDATLoaderEntry->setEntryType(CDATLoaderManager::getDATEntryTypeFromString(deqTokens[0]));
deqTokens.pop_front();
pDATLoaderEntry->setEntryValues(deqTokens);
addEntry(pDATLoaderEntry);
}
}
void CCOLEntry::parseCollisionBoxes(void)
{
CDataReader *pDataReader = CDataReader::getInstance();
vector<TBox>& vecBoxes = getCollisionBoxes();
for (uint32 i = 0, j = getCollisionBoxCount(); i < j; i++)
{
TBox box;
box.m_min.m_x = pDataReader->readFloat32();
box.m_min.m_y = pDataReader->readFloat32();
box.m_min.m_z = pDataReader->readFloat32();
box.m_max.m_x = pDataReader->readFloat32();
box.m_max.m_y = pDataReader->readFloat32();
box.m_max.m_z = pDataReader->readFloat32();
box.m_surface.m_ucMaterial = pDataReader->readUint8();
box.m_surface.m_ucFlag = pDataReader->readUint8();
box.m_surface.m_ucBrightness = pDataReader->readUint8();
box.m_surface.m_ucLight = pDataReader->readUint8();
vecBoxes.push_back(box);
}
}
void CIPLEntry_TCYC::unserialize(void)
{
CDataReader *pDataReader = CDataReader::getInstance();
switch (pDataReader->getLineTokens().size())
{
case 11:
setFormatType(0);
setFormatGames(GAME_FLAG_GTA_SA);
m_vecPositionLower = pDataReader->readTokenVector3D();
m_vecPositionUpper = pDataReader->readTokenVector3D();
m_uiUnknown1 = pDataReader->readTokenUint32();
m_uiWeatherId = pDataReader->readTokenUint32();
m_iBrightness = pDataReader->readTokenInt32();
m_uiTime = pDataReader->readTokenUint32();
m_uiDrawDistance = pDataReader->readTokenUint32();
break;
default:
throw EXCEPTION_UNKNOWN_FORMAT_TYPE;
}
}
void CCOLEntry::parseCollisionMeshFaceGroups(void)
{
CDataReader *pDataReader = CDataReader::getInstance();
vector<TFaceGroup>& vecFaceGroups = getCollisionMeshFaceGroups();
for (uint32 i = 0, j = getCollisionMeshFaceGroupCount(); i < j; i++)
{
TFaceGroup faceGroup;
faceGroup.m_min.m_x = pDataReader->readFloat32();
faceGroup.m_min.m_y = pDataReader->readFloat32();
faceGroup.m_min.m_z = pDataReader->readFloat32();
faceGroup.m_max.m_x = pDataReader->readFloat32();
faceGroup.m_max.m_y = pDataReader->readFloat32();
faceGroup.m_max.m_z = pDataReader->readFloat32();
faceGroup.m_startFace = pDataReader->readUint16();
faceGroup.m_endFace = pDataReader->readUint16();
vecFaceGroups.push_back(faceGroup);
}
}
void CIPLEntry_JUMP::unserialize(void)
{
CDataReader *pDataReader = CDataReader::getInstance();
switch (pDataReader->getLineTokens().size())
{
case 16:
setFormatType(0);
setFormatGames(GAME_FLAG_GTA_SA);
m_vecStartLowerPosition = pDataReader->readTokenVector3D();
m_vecStartUpperPosition = pDataReader->readTokenVector3D();
m_vecTargetLowerPosition = pDataReader->readTokenVector3D();
m_vecTargetUpperPosition = pDataReader->readTokenVector3D();
m_vecCameraPosition = pDataReader->readTokenVector3D();
m_uiReward = pDataReader->readTokenUint32();
break;
default:
throw EXCEPTION_UNKNOWN_FORMAT_TYPE;
}
}
eDATPathFormat CDATPathFormat::detectPathsFormat(void)
{
CDataReader *pDataReader = CDataReader::getInstance();
eDATPathFormat eDATPathFormatValue;
uint32 uiPreviousSeek = pDataReader->getSeek();
pDataReader->setPeek(true);
if (CStringUtility::unpackUint32(pDataReader->readString(4), false) == 0xFFFFFFFF && pDataReader->readString(4) == "FM92")
{
eDATPathFormatValue = DAT_PATH_FASTMAN92;
}
else
{
eDATPathFormatValue = DAT_PATH_DEFAULT;
}
pDataReader->setSeek(uiPreviousSeek);
pDataReader->setPeek(false);
return eDATPathFormatValue;
}
void CCOLEntry::parseCollisionMeshFaces(void)
{
CDataReader *pDataReader = CDataReader::getInstance();
eCOLVersion eCOLVersionValue = getCOLVersion() == nullptr ? COL_UNKNOWN : getCOLVersion()->getVersionId();
vector<TFace>& vecFaces = getCollisionMeshFaces();
for (uint32 i = 0, j = getCollisionMeshFaceCount(); i < j; i++)
{
TFace face;
if (eCOLVersionValue == COL_1)
{
face.m_uiA = pDataReader->readUint32();
face.m_uiB = pDataReader->readUint32();
face.m_uiC = pDataReader->readUint32();
face.m_surface.m_ucMaterial = pDataReader->readUint8();
face.m_surface.m_ucFlag = pDataReader->readUint8();
face.m_surface.m_ucBrightness = pDataReader->readUint8();
face.m_surface.m_ucLight = pDataReader->readUint8();
}
else
{
face.m_uiA = pDataReader->readUint16();
face.m_uiB = pDataReader->readUint16();
face.m_uiC = pDataReader->readUint16();
face.m_surface.m_ucMaterial = pDataReader->readUint8();
face.m_surface.m_ucFlag = 0;
face.m_surface.m_ucBrightness = 0;
face.m_surface.m_ucLight = pDataReader->readUint8();
}
vecFaces.push_back(face);
}
}
void CRWEntry_2dEffect_Light::unserialize(void)
{
CDataReader *pDataReader = CDataReader::getInstance();
m_uiColor = pDataReader->readUint32();
m_fCoronaFarClip = pDataReader->readFloat32();
m_fPointlightRange = pDataReader->readFloat32();
m_fCoronaSize = pDataReader->readFloat32();
m_fShadowSize = pDataReader->readFloat32();
m_ucCoronaShowMode = pDataReader->readUint8();
m_ucCoronaEnableReflection = pDataReader->readUint8();
m_ucCoronaFlareType = pDataReader->readUint8();
m_ucShadowColorMultiplier = pDataReader->readUint8();
m_ucFlags1 = pDataReader->readUint8();
m_strCoronaTexName = CStringUtility::rtrimFromLeft(pDataReader->readString(24));
m_strShadowTexName = CStringUtility::rtrimFromLeft(pDataReader->readString(24));
m_ucShadowZDistance = pDataReader->readUint8();
m_ucFlags2 = pDataReader->readUint8();
if (m_uiDataSize == 76)
{
m_vecPadding.m_x = pDataReader->readUint8();
m_vecPadding.m_y = 0;
}
else if (m_uiDataSize == 80)
{
m_vecLookDirection.m_x = pDataReader->readUint8();
m_vecLookDirection.m_y = pDataReader->readUint8();
m_vecLookDirection.m_z = pDataReader->readUint8();
m_vecPadding.m_x = pDataReader->readUint8();
m_vecPadding.m_y = pDataReader->readUint8();
}
}
void CDATPathFormat::unserializeFastman92(void)
{
CDataReader *pDataReader = CDataReader::getInstance();
m_uiFileIndex = 0; // uiAreaId;
//uint32 uiSeek = 0;
//uint32 uiSize;
m_header.m_ePathsFormat = DAT_PATH_FASTMAN92;
uint32 uiFourCC = pDataReader->readUint32(); // 0xFFFFFFFF
string strFormat = pDataReader->readString(4); // FM92
uint8 ucNicknameLength = pDataReader->readUint8();
string strNickname = pDataReader->readString(ucNicknameLength);
uint32 uiFormatVersion = pDataReader->readUint32();
m_header.m_uiPathNodeCount = pDataReader->readUint32();
m_header.m_uiVehicleNodeCount = pDataReader->readUint32();
m_header.m_uiPedNodeCount = pDataReader->readUint32();
m_header.m_uiNaviNodeCount = pDataReader->readUint32();
m_header.m_uiLinkCount = pDataReader->readUint32();
//uiSize = pDataReader->getByteCountRead();
//uiSeek += uiSize;
m_vecPathNodes.resize(m_header.m_uiPathNodeCount);
m_vecNaviNodes.resize(m_header.m_uiNaviNodeCount);
m_vecLinks.resize(m_header.m_uiLinkCount);
CDATEntry_Paths_Fastman92_PathNode_extended *pPathNodes = new CDATEntry_Paths_Fastman92_PathNode_extended[m_header.m_uiPathNodeCount];
CDATEntry_Paths_Fastman92_NaviNode_extended *pNaviNodes = new CDATEntry_Paths_Fastman92_NaviNode_extended[m_header.m_uiNaviNodeCount];
CDATEntry_Paths_Fastman92_Link *pLinks = new CDATEntry_Paths_Fastman92_Link[m_header.m_uiLinkCount];
CDATEntry_Paths_Fastman92_NaviLink *pNaviLinks = new CDATEntry_Paths_Fastman92_NaviLink[m_header.m_uiLinkCount];
CDATEntry_Paths_Fastman92_LinkLength *pLinkLengths = new CDATEntry_Paths_Fastman92_LinkLength[m_header.m_uiLinkCount];
CDATEntry_Paths_Fastman92_PathIntersectionFlags *pPathIntersectionFlags = new CDATEntry_Paths_Fastman92_PathIntersectionFlags[m_header.m_uiLinkCount];
/*
uiSize = pDATFile_Paths->m_header.m_uiPathNodeCount * 40;
memcpy(pPathNodes, strFileData.c_str() + uiSeek, uiSize);
uiSeek += uiSize;
uiSize = pDATFile_Paths->m_header.m_uiNaviNodeCount * 22;
memcpy(pNaviNodes, strFileData.c_str() + uiSeek, uiSize);
uiSeek += uiSize;
uiSize = pDATFile_Paths->m_header.m_uiLinkCount * 4;
memcpy(pLinks, strFileData.c_str() + uiSeek, uiSize);
uiSeek += uiSize;
uiSeek += 768;
uiSize = pDATFile_Paths->m_header.m_uiLinkCount * 4;
memcpy(pNaviLinks, strFileData.c_str() + uiSeek, uiSize);
uiSeek += uiSize;
uiSize = pDATFile_Paths->m_header.m_uiLinkCount * 1;
memcpy(pLinkLengths, strFileData.c_str() + uiSeek, uiSize);
uiSeek += uiSize;
*/
for (uint32 i = 0, j = m_header.m_uiPathNodeCount; i < j; i++)
{
CDATEntry_Paths_Fastman92_PathNode_extended *pPathNode_Fastman92 = pPathNodes + i;
pPathNode_Fastman92->m_pPrev = 0;
pDataReader->readUint32();
pPathNode_Fastman92->m_ppNext = 0;
pDataReader->readUint32();
pPathNode_Fastman92->m_posn.x = pDataReader->readUint16();
pPathNode_Fastman92->m_posn.y = pDataReader->readUint16();
pPathNode_Fastman92->m_posn.z = pDataReader->readUint16();
pPathNode_Fastman92->m_wSearchList = pDataReader->readUint16();
pPathNode_Fastman92->m_wConnectedNodesStartId = pDataReader->readUint16();
pPathNode_Fastman92->m_wAreaId = pDataReader->readUint16();
pPathNode_Fastman92->m_wNodeId = pDataReader->readUint16();
pPathNode_Fastman92->m_nPathWidth = pDataReader->readUint8();
pPathNode_Fastman92->m_nNodeType = pDataReader->readUint8();
pPathNode_Fastman92->m_dwFlags = pDataReader->readUint32();
pPathNode_Fastman92->m_extended_posn.x = pDataReader->readUint32();
pPathNode_Fastman92->m_extended_posn.y = pDataReader->readUint32();
pPathNode_Fastman92->m_extended_posn.z = pDataReader->readUint32();
}
for (uint32 i = 0, j = m_header.m_uiNaviNodeCount; i < j; i++)
{
CDATEntry_Paths_Fastman92_NaviNode_extended *pNaviNode_Fastman92 = pNaviNodes + i;
pNaviNode_Fastman92->posX = pDataReader->readUint16();
pNaviNode_Fastman92->posY = pDataReader->readUint16();
pNaviNode_Fastman92->info.areaId = pDataReader->readUint16();
pNaviNode_Fastman92->info.nodeId = pDataReader->readUint16();
pNaviNode_Fastman92->dirX = pDataReader->readUint8();
pNaviNode_Fastman92->dirY = pDataReader->readUint8();
pNaviNode_Fastman92->m_dwFlags = pDataReader->readUint32();
pNaviNode_Fastman92->extended_posX = pDataReader->readUint32();
pNaviNode_Fastman92->extended_posY = pDataReader->readUint32();
}
for (uint32 i = 0, j = m_header.m_uiLinkCount; i < j; i++)
{
CDATEntry_Paths_Fastman92_Link *pLink_Fastman92 = pLinks + i;
pLink_Fastman92->m_usAreaId = pDataReader->readUint16();
pLink_Fastman92->m_usNodeId = pDataReader->readUint16();
}
if (m_header.m_uiLinkCount > 0)
{
string strFiller1 = pDataReader->readString(768);
}
for (uint32 i = 0, j = m_header.m_uiLinkCount; i < j; i++)
{
CDATEntry_Paths_Fastman92_NaviLink *pNaviLink_Fastman92 = pNaviLinks + i;
pNaviLink_Fastman92->m_uiData = pDataReader->readUint32();
}
for (uint32 i = 0, j = m_header.m_uiLinkCount; i < j; i++)
{
CDATEntry_Paths_Fastman92_LinkLength *pLinkLength_Fastman92 = pLinkLengths + i;
pLinkLength_Fastman92->m_ucLength = pDataReader->readUint8();
}
for (uint32 i = 0, j = m_header.m_uiLinkCount; i < j; i++)
{
CDATEntry_Paths_Fastman92_PathIntersectionFlags *pPathIntersectionFlags_Fastman92 = pPathIntersectionFlags + i;
uint8 ucByte = pDataReader->readUint8();
//pPathIntersectionFlags_Fastman92->m_bRoadCross = ucByte & 1;
//pPathIntersectionFlags_Fastman92->m_bPedTrafficLight = ucByte & 2;
pPathIntersectionFlags_Fastman92->m_ucData = ucByte;
}
if (m_header.m_uiLinkCount > 0)
{
string strFiller2 = pDataReader->readString(192);
}
if (m_header.m_uiLinkCount > 0)
{
string strFiller3 = pDataReader->readString(192);
}
string strEOF = pDataReader->readString(4);
//
//if (strEOF.substr(0, 3) != "EOF")
//{
//CDebugger::log("PARSER FAILED on index " + CStringUtility::toString(pDATFile_Paths->m_uiFileIndex) + ", bytes read: " + CStringUtility::toString(pDataReader->getByteCountRead()));
//}
//
// --
for (uint32 i = 0, j = m_header.m_uiPathNodeCount; i < j; i++)
{
CDATEntry_Paths_Fastman92_PathNode_extended &pPathNode_Fastman92 = *(pPathNodes + i);
CDATEntry_Paths_General_PathNode &pPathNode_General = m_vecPathNodes[i];
pPathNode_General.m_bIsVehiclePathNode = i < m_header.m_uiVehicleNodeCount;
pPathNode_General.m_pPrev = 0;
pPathNode_General.m_ppNext = 0;
pPathNode_General.m_vecPosition.x = pPathNode_Fastman92.m_extended_posn.x;
pPathNode_General.m_vecPosition.y = pPathNode_Fastman92.m_extended_posn.y;
pPathNode_General.m_vecPosition.z = pPathNode_Fastman92.m_extended_posn.z;
pPathNode_General.m_wSearchList = pPathNode_Fastman92.m_wSearchList;
pPathNode_General.m_wConnectedNodesStartId = pPathNode_Fastman92.m_wConnectedNodesStartId;
pPathNode_General.m_wAreaId = pPathNode_Fastman92.m_wAreaId;
pPathNode_General.m_wNodeId = pPathNode_Fastman92.m_wNodeId;
pPathNode_General.m_ucPathWidth = pPathNode_Fastman92.m_nPathWidth;
pPathNode_General.m_ucNodeType = pPathNode_Fastman92.m_nNodeType;
pPathNode_General.m_uiFlags = pPathNode_Fastman92.m_dwFlags;
}
for (uint32 i = 0, j = m_header.m_uiNaviNodeCount; i < j; i++)
{
CDATEntry_Paths_Fastman92_NaviNode_extended &pNaviNode_Fastman92 = *(pNaviNodes + i);
CDATEntry_Paths_General_NaviNode &pNaviNode_General = m_vecNaviNodes[i];
pNaviNode_General.m_iPosition[0] = pNaviNode_Fastman92.extended_posX;
pNaviNode_General.m_iPosition[1] = pNaviNode_Fastman92.extended_posY;
pNaviNode_General.m_usTargetNode_AreaId = pNaviNode_Fastman92.info.areaId;
pNaviNode_General.m_usTargetNode_NodeId = pNaviNode_Fastman92.info.nodeId;
pNaviNode_General.m_ucDirection[0] = pNaviNode_Fastman92.dirX;
pNaviNode_General.m_ucDirection[1] = pNaviNode_Fastman92.dirY;
pNaviNode_General.m_uiFlags = pNaviNode_Fastman92.m_dwFlags;
}
for (uint32 i = 0, j = m_header.m_uiLinkCount; i < j; i++)
{
CDATEntry_Paths_Fastman92_Link &pLink_Fastman92 = *(pLinks + i);
CDATEntry_Paths_Fastman92_NaviLink &pNaviLink_Fastman92 = *(pNaviLinks + i);
CDATEntry_Paths_Fastman92_LinkLength &pLinkLength_Fastman92 = *(pLinkLengths + i);
CDATEntry_Paths_Fastman92_PathIntersectionFlags &pPathIntersectionFlags_Fastman92 = *(pPathIntersectionFlags + i);
CDATEntry_Paths_General_Link &pLink_General = m_vecLinks[i];
pLink_General.m_usAreaId = pLink_Fastman92.m_usAreaId;
pLink_General.m_usNodeId = pLink_Fastman92.m_usNodeId;
pLink_General.m_usNaviNodeId = pNaviLink_Fastman92.m_uiData & 0xFFFF; // lower 16 bits
pLink_General.m_usNaviAreaId = (pNaviLink_Fastman92.m_uiData >> 16) & 0xFFFF; // upper 16 bits
pLink_General.m_ucLength = pLinkLength_Fastman92.m_ucLength;
uint8 ucByte = 0;
//ucByte |= pPathIntersectionFlags_Fastman92.m_bRoadCross ? 1 : 0;
//ucByte |= pPathIntersectionFlags_Fastman92.m_bPedTrafficLight ? 2 : 0;
pLink_General.m_ucPathIntersectionFlags = pPathIntersectionFlags_Fastman92.m_ucData;
}
/*
// debug
for (auto& pathNode : m_vecPathNodes)
{
CDebugger::log(
"[path node]"
+ string(" position: ") + CStringUtility::toString((float32)((float32)pathNode.m_vecPosition.x / 8.0)) + " "
+ CStringUtility::toString((float32)((float32)pathNode.m_vecPosition.y / 8.0)) + " "
+ CStringUtility::toString((float32)((float32)pathNode.m_vecPosition.z / 8.0)) + " "
+ " search list: " + CStringUtility::toString(pathNode.m_wSearchList)
+ " first link id: " + CStringUtility::toString(pathNode.m_wConnectedNodesStartId)
+ " area id: " + CStringUtility::toString(pathNode.m_wAreaId) + " node id: " + CStringUtility::toString(pathNode.m_wNodeId)
+ " path width: " + CStringUtility::toString(pathNode.m_ucPathWidth)
+ " node type: " + CStringUtility::toString(pathNode.m_ucNodeType)
+ " flags: " + CStringUtility::toString(pathNode.m_uiFlags)
);
}
for (auto& naviNode : m_vecNaviNodes)
{
CDebugger::log(
"[navi node]"
+ string(" position: ") + CStringUtility::toString((float32)((float32)naviNode.m_iPosition[0] / 8.0)) + " "
+ CStringUtility::toString((float32)((float32)naviNode.m_iPosition[1] / 8.0)) + " "
+ " area id: " + CStringUtility::toString(naviNode.m_usTargetNode_AreaId) + " node id: " + CStringUtility::toString(naviNode.m_usTargetNode_NodeId)
+ " direction x: " + CStringUtility::toString(naviNode.m_ucDirection[0]) + " direction y " + CStringUtility::toString(naviNode.m_ucDirection[1])
+ " flags: " + CStringUtility::toString(naviNode.m_uiFlags)
);
}
*/
// clean up
delete[] pPathNodes;
delete[] pNaviNodes;
delete[] pLinks;
delete[] pNaviLinks;
delete[] pLinkLengths;
delete[] pPathIntersectionFlags;
}
void CDATPathFormat::unserializeDefault(void)
{
CDataReader *pDataReader = CDataReader::getInstance();
m_uiFileIndex = 0;// uiAreaId;
uint32 uiSeek = 0;
uint32 uiSize;
CDATEntry_Paths_Default_Header *pHeader1 = pDataReader->readStruct<CDATEntry_Paths_Default_Header>();
m_header.m_ePathsFormat = DAT_PATH_DEFAULT;
m_header.m_uiPathNodeCount = pHeader1->m_uiPathNodeCount;
m_header.m_uiVehicleNodeCount = pHeader1->m_uiVehicleNodeCount;
m_header.m_uiPedNodeCount = pHeader1->m_uiPedNodeCount;
m_header.m_uiNaviNodeCount = pHeader1->m_uiNaviNodeCount;
m_header.m_uiLinkCount = pHeader1->m_uiLinkCount;
uiSize = 20;
uiSeek += uiSize;
m_vecPathNodes.resize(m_header.m_uiPathNodeCount);
m_vecNaviNodes.resize(m_header.m_uiNaviNodeCount);
m_vecLinks.resize(m_header.m_uiLinkCount);
CDATEntry_Paths_Default_PathNode *pPathNodes = new CDATEntry_Paths_Default_PathNode[m_header.m_uiPathNodeCount];
CDATEntry_Paths_Default_NaviNode *pNaviNodes = new CDATEntry_Paths_Default_NaviNode[m_header.m_uiNaviNodeCount];
CDATEntry_Paths_Default_Link *pLinks = new CDATEntry_Paths_Default_Link[m_header.m_uiLinkCount];
CDATEntry_Paths_Default_NaviLink *pNaviLinks = new CDATEntry_Paths_Default_NaviLink[m_header.m_uiLinkCount];
CDATEntry_Paths_Default_LinkLength *pLinkLengths = new CDATEntry_Paths_Default_LinkLength[m_header.m_uiLinkCount];
uiSize = m_header.m_uiPathNodeCount * 28;
memcpy(pPathNodes, pDataReader->readCString(uiSize), uiSize);
uiSeek += uiSize;
uiSize = m_header.m_uiNaviNodeCount * 14;
memcpy(pNaviNodes, pDataReader->readCString(uiSize), uiSize);
uiSeek += uiSize;
uiSize = m_header.m_uiLinkCount * 4;
memcpy(pLinks, pDataReader->readCString(uiSize), uiSize);
uiSeek += uiSize;
uiSeek += 768;
uiSize = m_header.m_uiLinkCount * 2;
memcpy(pNaviLinks, pDataReader->readCString(uiSize), uiSize);
uiSeek += uiSize;
uiSize = m_header.m_uiLinkCount * 1;
memcpy(pLinkLengths, pDataReader->readCString(uiSize), uiSize);
uiSeek += uiSize;
for (uint32 i = 0, j = m_header.m_uiPathNodeCount; i < j; i++)
{
CDATEntry_Paths_Default_PathNode &pPathNode_Default = *(pPathNodes + i);
CDATEntry_Paths_General_PathNode &pPathNode_General = m_vecPathNodes[i];
pPathNode_General.m_vecPosition.x = pPathNode_Default.m_iPosition[0];
pPathNode_General.m_vecPosition.y = pPathNode_Default.m_iPosition[1];
pPathNode_General.m_vecPosition.z = pPathNode_Default.m_iPosition[2];
pPathNode_General.m_wLinkId = pPathNode_Default.m_usLinkId;
pPathNode_General.m_wNodeId = pPathNode_Default.m_usNodeId;
pPathNode_General.m_wAreaId = pPathNode_Default.m_usAreaId;
pPathNode_General.m_ucPathWidth = pPathNode_Default.m_ucPathWidth;
pPathNode_General.m_ucNodeType = pPathNode_Default.m_ucNodeType;
pPathNode_General.m_uiFlags = pPathNode_Default.m_uiFlags;
}
for (uint32 i = 0, j = m_header.m_uiNaviNodeCount; i < j; i++)
{
CDATEntry_Paths_Default_NaviNode &pNaviNode_Default = *(pNaviNodes + i);
CDATEntry_Paths_General_NaviNode &pNaviNode_General = m_vecNaviNodes[i];
pNaviNode_General.m_iPosition[0] = pNaviNode_Default.m_iPosition[0];
pNaviNode_General.m_iPosition[1] = pNaviNode_Default.m_iPosition[1];
pNaviNode_General.m_ucDirection[0] = pNaviNode_Default.m_ucDirection[0];
pNaviNode_General.m_ucDirection[1] = pNaviNode_Default.m_ucDirection[1];
pNaviNode_General.m_uiFlags = pNaviNode_Default.m_uiFlags;
pNaviNode_General.m_usTargetNode_NodeId = pNaviNode_Default.m_usNodeId;
pNaviNode_General.m_usTargetNode_AreaId = pNaviNode_Default.m_usAreaId;
}
for (uint32 i = 0, j = m_header.m_uiLinkCount; i < j; i++)
{
CDATEntry_Paths_Default_Link &pLink_Default = *(pLinks + i);
CDATEntry_Paths_Default_NaviLink &pNaviLink_Default = *(pNaviLinks + i);
CDATEntry_Paths_Default_LinkLength &pLinkLength_Default = *(pLinkLengths + i);
CDATEntry_Paths_General_Link &pLink_General = m_vecLinks[i];
pLink_General.m_usAreaId = pLink_Default.m_usAreaId;
pLink_General.m_usNodeId = pLink_Default.m_usNodeId;
pLink_General.m_usNaviNodeId = pNaviLink_Default.m_usData & 0x3FF; // lower 10 bits
pLink_General.m_usNaviAreaId = (pNaviLink_Default.m_usData >> 10) & 0x3F; // upper 6 bits
pLink_General.m_ucLength = pLinkLength_Default.m_ucLength;
}
delete[] pHeader1;
delete[] pPathNodes;
delete[] pNaviNodes;
delete[] pLinks;
delete[] pNaviLinks;
delete[] pLinkLengths;
}
void CCOLEntry::parseCollisionSpheres(void)
{
CDataReader *pDataReader = CDataReader::getInstance();
eCOLVersion eCOLVersionValue = getCOLVersion() == nullptr ? COL_UNKNOWN : getCOLVersion()->getVersionId();
vector<TSphere>& vecSpheres = getCollisionSpheres();
for (uint32 i = 0, j = getCollisionSphereCount(); i < j; i++)
{
TSphere sphere;
if (eCOLVersionValue == COL_1)
{
sphere.m_fRadius = pDataReader->readFloat32();
sphere.m_vecCenter.m_x = pDataReader->readFloat32();
sphere.m_vecCenter.m_y = pDataReader->readFloat32();
sphere.m_vecCenter.m_z = pDataReader->readFloat32();
sphere.m_surface.m_ucMaterial = pDataReader->readUint8();
sphere.m_surface.m_ucFlag = pDataReader->readUint8();
sphere.m_surface.m_ucBrightness = pDataReader->readUint8();
sphere.m_surface.m_ucLight = pDataReader->readUint8();
}
else
{
sphere.m_vecCenter.m_x = pDataReader->readFloat32();
sphere.m_vecCenter.m_y = pDataReader->readFloat32();
sphere.m_vecCenter.m_z = pDataReader->readFloat32();
sphere.m_fRadius = pDataReader->readFloat32();
sphere.m_surface.m_ucMaterial = pDataReader->readUint8();
sphere.m_surface.m_ucFlag = pDataReader->readUint8();
sphere.m_surface.m_ucBrightness = pDataReader->readUint8();
sphere.m_surface.m_ucLight = pDataReader->readUint8();
}
vecSpheres.push_back(sphere);
}
}