Example #1
0
void							CRWSection_Texture::unserialize(void)
{
	CDataReader *pDataReader = CDataReader::getInstance();

	m_usFilterFlags = pDataReader->readUint16();
	m_usUnknown1 = pDataReader->readUint16();
}
Example #2
0
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;
	}
}
Example #3
0
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;
}
Example #4
0
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);
	}
}
Example #5
0
void					CDATLoaderFormat::unserialize(void)
{
	CDataReader *pDataReader = CDataReader::getInstance();
	pDataReader->readAndStoreLines();
	while (pDataReader->iterateLines())
	{
		unserializeLine();
	}
}
Example #6
0
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;
	}
}
Example #7
0
void			CLocalizationFormat::unserialize(void)
{
	CDataReader *pDataReader = CDataReader::getInstance();
	pDataReader->readAndStoreLines();
	while (pDataReader->iterateLines())
	{
		unserializeLine();
	}
	pDataReader->resetLines();
}
Example #8
0
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;
}
Example #9
0
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();
}
Example #10
0
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();
}
Example #11
0
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);
	}
}
Example #12
0
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);
}
Example #13
0
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;
	}
}
Example #14
0
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;
}
Example #15
0
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);
	}
}
Example #16
0
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;
	}
}
Example #17
0
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);
}
Example #18
0
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;
}
Example #19
0
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;
}
Example #20
0
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);
	}
}
Example #21
0
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);
	}
}
Example #22
0
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;
	}
}
Example #23
0
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);
	}
}
Example #24
0
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;
    }
}
Example #25
0
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;
}
Example #26
0
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);
	}
}
Example #27
0
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();
	}
}
Example #28
0
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;
}
Example #29
0
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;
}
Example #30
0
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);
	}
}