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 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 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 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();
}
}
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 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 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 CCOLEntry::unserialize(void)
{
CDataReader *pDataReader = CDataReader::getInstance();
uint32 uiHeaderStartPosition = pDataReader->getSeek();
setHeaderStartOffset(uiHeaderStartPosition);
// COL 1 2 3 & 4 header
setCOLVersion(CCOLManager::getCOLVersionFromFourCC(pDataReader->readString(4)));
if (getCOLVersion() == nullptr)
{
throw EXCEPTION_UNKNOWN_FORMAT;
}
uint32 uiEntrySize = pDataReader->readUint32(); // entry size from after this value
setModelName(CStringUtility::rtrimFromLeft(pDataReader->readString(22)));
setModelId(pDataReader->readUint16());
parseBoundingObjects();
eCOLVersion eCOLVersionValue = getCOLVersion() == nullptr ? COL_UNKNOWN : getCOLVersion()->getVersionId();
if (eCOLVersionValue == COL_1)
{
// COL 1 header & body
// read collision sphere count
setCollisionSphereCount(pDataReader->readUint32());
// read collision spheres array
setCollisionSpheresOffset(pDataReader->getSeek());
parseCollisionSpheres();
// read unknown1 count
setUnknown1(pDataReader->readUint32()); // number of unknown data (0)
// read collision box count
setCollisionBoxCount(pDataReader->readUint32());
// read collision boxes array
setCollisionBoxesOffset(pDataReader->getSeek());
parseCollisionBoxes();
// read collision mesh vertex count
setCollisionMeshVertexCount(pDataReader->readUint32());
// read collision mesh vertices array
setCollisionMeshVerticesOffset(pDataReader->getSeek());
parseCollisionMeshVertices();
// read collision mesh face count
setCollisionMeshFaceCount(pDataReader->readUint32());
// read collision mesh faces array
setCollisionMeshFacesOffset(pDataReader->getSeek());
parseCollisionMeshFaces();
}
else
{
// COL 2 3 & 4 header
setCollisionSphereCount(pDataReader->readUint16());
setCollisionBoxCount(pDataReader->readUint16());
setCollisionMeshFaceCount(pDataReader->readUint16());
setCollisionConeCount(pDataReader->readUint8());
uint8 ucPadding1 = pDataReader->readUint8(); // 1 byte padding
setFlags(pDataReader->readUint32());
setCollisionSpheresOffset(pDataReader->readUint32());
setCollisionBoxesOffset(pDataReader->readUint32());
setCollisionConesOffset(pDataReader->readUint32());
setCollisionMeshVerticesOffset(pDataReader->readUint32());
setCollisionMeshFacesOffset(pDataReader->readUint32());
setTrianglePlanesOffset(pDataReader->readUint32());
if ((getFlags() & 8) != 0)
{
// entry does have face groups
uint32 uiCurrentSeek = pDataReader->getSeek();
// read face group count
uint32 uiFaceGroupCountSeek = (getHeaderStartOffset() + 4 + getCollisionMeshFacesOffset()) - 4;
pDataReader->setSeek(uiFaceGroupCountSeek);
setCollisionMeshFaceGroupCount(pDataReader->readUint32());
// read face groups offset
setCollisionMeshFaceGroupsOffset((getCollisionMeshFacesOffset() - 4) - (28 * getCollisionMeshFaceGroupCount())); // 28 = sizeof(TFaceGroup)
// restore parser seek position
pDataReader->setSeek(uiCurrentSeek);
}
else
{
// entry does not have face groups
setCollisionMeshFaceGroupCount(0);
setCollisionMeshFaceGroupsOffset(0);
}
if (eCOLVersionValue == COL_3 || eCOLVersionValue == COL_4)
{
// COL 3 & 4 header
setShadowMeshFaceCount(pDataReader->readUint32());
setShadowMeshVerticesOffset(pDataReader->readUint32());
setShadowMeshFacesOffset(pDataReader->readUint32());
if (eCOLVersionValue == COL_4)
{
// COL 4 header
setUnknown1(pDataReader->readUint32());
}
}
// calculate vertex counts
// COL 2 3 & 4
uint32 uiCollisionMeshVertexCount = calculateCollisionMeshVertexCount();
setCollisionMeshVertexCount(uiCollisionMeshVertexCount);
if (eCOLVersionValue == COL_3 || eCOLVersionValue == COL_4)
{
// COL 3 & 4
uint32 uiShadowMeshVertexCount = calculateShadowMeshVertexCount();
setShadowMeshVertexCount(uiShadowMeshVertexCount);
}
// COL 2 3 & 4 body
pDataReader->setSeek(getHeaderStartOffset() + 4 + getCollisionSpheresOffset());
parseCollisionSpheres();
pDataReader->setSeek(getHeaderStartOffset() + 4 + getCollisionBoxesOffset());
parseCollisionBoxes();
pDataReader->setSeek(getHeaderStartOffset() + 4 + getCollisionMeshVerticesOffset());
parseCollisionMeshVertices();
pDataReader->setSeek(getHeaderStartOffset() + 4 + getCollisionMeshFaceGroupsOffset());
parseCollisionMeshFaceGroups();
pDataReader->setSeek(getHeaderStartOffset() + 4 + getCollisionMeshFacesOffset());
parseCollisionMeshFaces();
if (eCOLVersionValue == COL_3 || eCOLVersionValue == COL_4)
{
// COL 3 & 4 body
pDataReader->setSeek(getHeaderStartOffset() + 4 + getShadowMeshVerticesOffset());
parseShadowMeshVertices();
pDataReader->setSeek(getHeaderStartOffset() + 4 + getShadowMeshFacesOffset());
parseShadowMeshFaces();
}
}
if (!pDataReader->canSeekTo(getHeaderStartOffset() + uiEntrySize + 8))
{
// EOF
return;
}
pDataReader->setSeek(getHeaderStartOffset() + uiEntrySize + 8);
}
void CRWSection_Geometry::unserialize(void)
{
CDataReader *pDataReader = CDataReader::getInstance();
m_usFlags = pDataReader->readUint16();
m_ucUVCoordinateCount = pDataReader->readUint8();
if (m_usFlags & 4)
{
m_ucUVCoordinateCount = 1;
}
m_ucGeometryNativeFlags = pDataReader->readUint8();
m_uiTriangleCount = pDataReader->readUint32();
m_uiVertexCount = pDataReader->readUint32();
m_uiFrameCount = pDataReader->readUint32();
if (m_uiSectionRWVersion < 0x1003FFFF)
{
m_uiAmbientColour = pDataReader->readUint32();
m_uiDiffuseColour = pDataReader->readUint32();
m_uiSpecularColour = pDataReader->readUint32();
}
else
{
m_uiAmbientColour = 1;
m_uiDiffuseColour = 1;
m_uiSpecularColour = 1;
}
if (!m_ucGeometryNativeFlags)
{
if (m_usFlags & 8)
{
m_vecVertexColours = pDataReader->readVector4ui8ArrayAsStdVector(m_uiVertexCount);
}
if (m_usFlags & 4)
{
m_vecTextureCoordinates = pDataReader->readVector2DArrayAsStdVector(m_uiVertexCount);
}
if (m_usFlags & 128)
{
for (uint32 i = 0, j = m_ucUVCoordinateCount; i < j; i++)
{
m_vecTextureCoordinates = pDataReader->readVector2DArrayAsStdVector(m_uiVertexCount);
}
}
m_vecVertexIndices = pDataReader->readVector4ui16ArrayAsStdVector(m_uiTriangleCount);
}
m_boundingInfo.setCenter(pDataReader->readVector3D());
m_boundingInfo.setCenterRadius(pDataReader->readFloat32());
m_boundingInfo.setHasPosition(pDataReader->readUint32() != 0);
m_boundingInfo.setHasNormals(pDataReader->readUint32() != 0);
if (!m_ucGeometryNativeFlags)
{
if ((m_usFlags & 2) || m_boundingInfo.doesHavePosition() /* || true */)
{
m_vecTextureCoordinates = pDataReader->readVector2DArrayAsStdVector(m_uiVertexCount); // todo - store multiple texture coordinates so data loss doesn't occur
}
if ((m_usFlags & 16) || m_boundingInfo.doesHaveNormals())
{
m_vecVertexNormals = pDataReader->readVector3DArrayAsStdVector(m_uiVertexCount);
}
}
}
void CRWSectionContainer::unserialize(void)
{
CDataReader *pDataReader = CDataReader::getInstance();
CRWSectionContainer *pParentRWSectionContainer = this;
uint32 uiSectionDepth = 0;
vector<uint32>
vecSectionSizes,
vecByteCountsRead;
while (!pDataReader->isEOF())
{
if (!pDataReader->canRead(12))
{
break;
}
// read section header
uint32
uiRWSectionId = pDataReader->readUint32(),
uiRWSectionSize = pDataReader->readUint32(),
uiRWSectionRWVersion = pDataReader->readUint32();
eRWSection eRWSectionValue = (eRWSection)uiRWSectionId;
// enter new section
if (uiRWSectionId != 1)
{
vecSectionSizes.push_back(uiRWSectionSize);
vecByteCountsRead.push_back(0);
uiSectionDepth++;
}
// read struct header
if (CRWSection::doesRWSectionContainStruct(eRWSectionValue))
{
uint32
uiRWSectionId2 = pDataReader->readUint32(),
uiRWSectionSize2 = pDataReader->readUint32(),
uiRWSectionRWVersion2 = pDataReader->readUint32();
}
// create RW section
CRWSection *pRWSection = CRWSection::createRWSection(eRWSectionValue);
// unserialize RW section
uint32 uiByteCountBefore = pDataReader->getSeek();
pRWSection->unserialize();
uint32 uiByteCountAfter = pDataReader->getSeek();
vecByteCountsRead[uiSectionDepth - 1] += uiByteCountAfter - uiByteCountBefore;
// store RW section
pParentRWSectionContainer->addEntry(pRWSection);
// reset section depth
if (vecByteCountsRead[uiSectionDepth - 1] >= vecSectionSizes[uiSectionDepth - 1])
{
pParentRWSectionContainer = pParentRWSectionContainer->getParentNode();
vecSectionSizes.pop_back();
vecByteCountsRead[uiSectionDepth - 2] += vecByteCountsRead[uiSectionDepth - 1];
vecByteCountsRead.pop_back();
uiSectionDepth--;
}
}
}