void CGhostPlayer::loadGhostFile(const c8 *sFile) { if (m_pReplayLap!=NULL) delete m_pReplayLap; m_pReplayLap=new CGhostLaps(0); u32 iSize=0,iSteps=0; c8 sBuffer[0xFF]; CSerializer cData; printf("open %s\n",sFile); IFileSystem *pFs=m_pDevice->getFileSystem(); IReadFile *f=pFs->createAndOpenFile(path(sFile)); f->read(&iSize,sizeof(u32)); f->read(sBuffer,iSize); cData.setBuffer(sBuffer,iSize); CGhostHeader cHead(&cData); printf("\t\t--> %s\n\t\t--> %s\n\t\t--> %s\n",cHead.getPlayer(),cHead.getLevel(),cHead.getIdent()); while (f->getPos()<f->getSize()) { f->read(&iSize,sizeof(u32)); f->read(sBuffer,iSize); cData.setBuffer(sBuffer,iSize); CGhostState *pState=new CGhostState(&cData); m_pReplayLap->m_lStates.push_back(pState); iSteps++; } printf("%i steps\n",iSteps); m_it=m_pReplayLap->m_lStates.end(); f->drop(); }
bool CGhostPlayer::validateGhostFile(const c8 *sFile, c8 *sPlayer, c8 *sLevel, u32 *iSteps) { bool bRet=true; u32 iSize=0; c8 sBuffer[0xFF]; CSerializer cData; *iSteps=0; printf("open %s\n",sFile); IFileSystem *pFs=m_pDevice->getFileSystem(); IReadFile *f=pFs->createAndOpenFile(path(sFile)); f->read(&iSize,sizeof(u32)); f->read(sBuffer,iSize); cData.setBuffer(sBuffer,iSize); CGhostHeader cHead(&cData); if (!strcmp(cHead.getIdent(),"StuntMarbleRacersGhostFile")) { strcpy(sPlayer,cHead.getPlayer()); strcpy(sLevel ,cHead.getLevel ()); while (f->getPos()<f->getSize()) { f->read(&iSize,sizeof(u32)); bRet=bRet && iSize==24; f->read(sBuffer,iSize); cData.setBuffer(sBuffer,iSize); CGhostState cState(&cData); (*iSteps)++; } } f->drop(); return bRet && !strcmp(cHead.getIdent(),"StuntMarbleRacersGhostFile"); }
MessageBlock::MessageBlock(CSerializer & __is) :_command() ,_messageBase() , __os() { __is.read(_command); int size = 0; __is.read(size); // toIdList for (int i = 0; i < size; i++) { int dummy = 0; __is.read(dummy); } std::string msgName; __is.read(msgName); _messageBase = createMessageBase(msgName); if (nullptr != _messageBase) { _messageBase->__read(__is); } }
void CSocketClient::OnReceive(int nErrorCode) { // TODO: Add your specialized code here and/or call the base class // TODO: 通知客户端接到消息了 m_nLength=Receive(m_yBuffer,sizeof(m_yBuffer),0); // 解析数据包 CMemoryBuffer memoryBuffer(m_yBuffer, sizeof(m_yBuffer)); CSerializer arc; if(!arc.BeginReading(&memoryBuffer, false)) { OutputDebugString(_T("ClientSocket: 网络包解析失败!")); return; } WORD wMsgID = -1; // 循环取信息 while(1) { arc >> wMsgID; // 通知网络层收到消息 [11/22/2010 Kaiming-Laptop] if( !this->OnMsgFromServer(wMsgID, arc) ) break; } // 收到信息以后就清空 m_nLength=0; memset(m_yBuffer,0,sizeof(m_yBuffer)); //AsyncSelect(FD_READ); CSocket::OnReceive(nErrorCode); }
//-------------------------------------------------- // Save //-------------------------------------------------- bool CDetectorPeak::Save ( CSerializer & oSerialBuf ) const { bool bSuccess; bSuccess = CPeak::Save( oSerialBuf ); bSuccess = bSuccess && oSerialBuf.InsertCompactObj( bInitialized ); bSuccess = bSuccess && oSerialBuf.InsertCompactObj( oBBox ); DEBUG_ASSERT( bSuccess, "CDetectorPeak::Save failed\n"); return bSuccess; }
//------------------------------------------------------------------------- // Save //------------------------------------------------------------------------- bool CPeak::Save ( CSerializer & oSerialBuf ) const { bool bSuccess; bSuccess = oSerialBuf.InsertCompactObj( dMaxIntensity ); bSuccess = bSuccess && oSerialBuf.InsertCompactObj( dMinIntensity ); bSuccess = bSuccess && oSerialBuf.InsertCompactObj( PixelsSorted ); bSuccess = bSuccess && oSerialBuf.InsertCompactVector( vPixelList ); DEBUG_ASSERT( bSuccess, "CPeak::Save failed\n"); return bSuccess; }
//------------------------------------------------------------------------ // // Save // //------------------------------------------------------------------------ Bool ReconstructionSetup::Save ( CSerializer & oSerialBuf ) const { Bool bSuccess; bSuccess = oSerialBuf.InsertCompactObj ( FPeakFilter ); bSuccess = bSuccess && oSerialBuf.InsertCompactObj ( FPeakIntensityAccept ); bSuccess = bSuccess && oSerialBuf.InsertCompactVector ( oFZOrientationList ); bSuccess = bSuccess && oExpSetup.Save ( oSerialBuf ); bSuccess = bSuccess && oReconstructionLayer.Save ( oSerialBuf ); return bSuccess; }
bool CTextureAtlas::Load() { BEATS_ASSERT(!IsLoaded()); TString fileext = CFilePathTool::GetInstance()->Extension(GetFilePath().c_str()); if(fileext == _T(".xml")) { TiXmlDocument doc; CSerializer serializer; CFilePathTool::GetInstance()->LoadFile(&serializer, GetFilePath().c_str(), _T("rb")); if (serializer.GetWritePos() != serializer.GetReadPos()) { doc.Parse((char*)serializer.GetReadPtr()); } TiXmlElement *root = doc.RootElement(); BEATS_ASSERT(root && strcmp(root->Value(), "Imageset") == 0, _T("TextureAtlas file %s not found or incorrect!"), GetFilePath().c_str()); const char *textureFile = root->Attribute("Imagefile"); BEATS_ASSERT(textureFile); TCHAR szNameBuffer[MAX_PATH]; CStringHelper::GetInstance()->ConvertToTCHAR(textureFile, szNameBuffer, MAX_PATH); m_texture = CResourceManager::GetInstance()->GetResource<CTexture>(szNameBuffer); kmVec2 size; kmVec2 point; TString strName; for(TiXmlElement *elemImage = root->FirstChildElement("Image"); elemImage != nullptr; elemImage = elemImage->NextSiblingElement("Image")) { const char *name = elemImage->Attribute("Name"); BEATS_ASSERT(name); kmVec2Fill(&point, 0.f, 0.f); kmVec2Fill(&size, 0.f, 0.f); elemImage->QueryFloatAttribute("XPos", &point.x); elemImage->QueryFloatAttribute("YPos", &point.y); elemImage->QueryFloatAttribute("Width", &size.x); elemImage->QueryFloatAttribute("Height", &size.y); CStringHelper::GetInstance()->ConvertToTCHAR(name, szNameBuffer, MAX_PATH); strName.assign(szNameBuffer); CreateTextureFrag(strName, point, size); } } else { m_texture = CResourceManager::GetInstance()->GetResource<CTexture>(GetFilePath()); } m_name = CFilePathTool::GetInstance()->FileName(GetFilePath().c_str()); super::Load(); return true; }
void CEditLanguageDialog::OnButtonExport( wxCommandEvent& /*event*/ ) { // 1. Export Bin File. bool bExportBin = false; int count = m_languageMap.size(); CSerializer tmp; tmp << count; for (auto iter = m_languageMap.begin(); iter != m_languageMap.end(); iter++) { tmp << iter->first; tmp << iter->second[0]; tmp << iter->second[1]; } TString FilePath = CResourcePathManager::GetInstance()->GetResourcePath(CResourcePathManager::eRPT_Language) + _T("Language.bin"); bExportBin = tmp.Deserialize(FilePath.c_str()); //2. Export enum file. bool bExporthead; std::string content; content.append("#ifndef FCENGINEEDITOR_LANGUAGEENUM_H__INCLUDE\n#define FCENGINEEDITOR_LANGUAGEENUM_H__INCLUDE\n").append("\nenum ELanguage\n{\n"); char szBuffer[128]; for (auto iter = m_languageMap.begin(); iter != m_languageMap.end(); iter++) { CStringHelper::GetInstance()->ConvertToCHAR(iter->first.c_str(), szBuffer, 128); content.append(" ").append(szBuffer).append(",\n"); } content.append("\n eL_Count,\n").append(" eL_Force32Bit = 0xFFFFFFFF\n};\n"); content.append("\n#endif"); tmp.Reset(); tmp << content; FilePath = CResourcePathManager::GetInstance()->GetResourcePath(CResourcePathManager::eRPT_SourceCode) + _T("Language.h"); bExporthead = tmp.Deserialize(FilePath.c_str(), _T("wt+")); //Export hint. TString strMessage; if (bExportBin && bExporthead) { strMessage = _T("Export Bin File and enum file are succeed."); } else { strMessage = _T("Export Bin File or enum file are failed."); } wxMessageDialog* pMessageDlg = new wxMessageDialog(this, strMessage, _T("Edit Language"), wxOK|wxCENTRE|wxICON_NONE); pMessageDlg->ShowModal(); }
void CPlayerPrefs::Save() { if (m_strSavePath.empty()) { m_strSavePath = CResourceManager::GetInstance()->GetPersistentDataPath().append(_T("/")).append(_T("PlayerPrefs")); } CSerializer serializer; uint32_t uMapSize = m_dataMap.size(); serializer << uMapSize; for (auto itr : m_dataMap) { serializer << itr.first; serializer << itr.second; } serializer.Deserialize(m_strSavePath.c_str()); serializer.Reset(); }
void CEnumStrGenerator::SaveCacheFile(const TCHAR* pszCacheFileName) { CSerializer serializer; serializer << m_enumStrPool.size(); std::map<TString, SEnumScanData*>::iterator iter = m_enumStrPool.begin(); for (; iter != m_enumStrPool.end(); ++iter) { serializer << iter->first; serializer << iter->second->m_enumFilePath; serializer << iter->second->m_enumValue.size(); for (uint32_t i = 0; i < iter->second->m_enumValue.size(); ++i) { serializer << iter->second->m_enumValue[i]->m_str; serializer << iter->second->m_enumValue[i]->m_value; } } TString fullPathStr = CFilePathTool::GetInstance()->ParentPath(CUtilityManager::GetInstance()->GetModuleFileName().c_str()); fullPathStr.append(_T("/")).append(pszCacheFileName); serializer.Deserialize(fullPathStr.c_str()); }
void CComponentInstanceManager::LoadFile(uint32_t uFileId, std::vector<CComponentBase*>* pLoadComponents) { uint32_t uFileStartPos = 0; uint32_t uFileDataLength = 0; bool bRet = m_pProject->QueryFileLayoutInfo(uFileId, uFileStartPos, uFileDataLength); BEATS_ASSERT(bRet, _T("Query file layout info failed! file id %d"), uFileId); if (bRet) { // Use a serializer proxy to avoid multi-thread load the same serializer CSerializer dataProxy; dataProxy.SetBuffer(m_pSerializer->GetBuffer(), m_pSerializer->GetWritePos(), false); std::vector<CComponentInstance*> loadComponents; dataProxy.SetReadPos(uFileStartPos); uint32_t uFileStartPosRead, uFileDataLengthRead; dataProxy >> uFileStartPosRead >> uFileDataLengthRead; BEATS_ASSERT(uFileStartPosRead == uFileStartPos && uFileDataLengthRead == uFileDataLength); uint32_t uComponentCount = 0; dataProxy >> uComponentCount; bool bOriginalLoadPhase = IsInLoadingPhase(); BEATS_ASSERT(!bOriginalLoadPhase, "I don't think it will nest!"); SetLoadPhaseFlag(true); for (uint32_t j = 0; j < uComponentCount; ++j) { uint32_t uComponentDataSize, uGuid, uId; uint32_t uComponentStartPos = dataProxy.GetReadPos(); dataProxy >> uComponentDataSize >> uGuid >> uId; CComponentInstance* pComponent = down_cast<CComponentInstance*>(CComponentInstanceManager::GetInstance()->CreateComponent(uGuid, false, false, uId, true, &dataProxy, false)); pComponent->SetDataPos(uComponentStartPos); pComponent->SetDataSize(uComponentDataSize); BEATS_ASSERT(pComponent != NULL); if (pLoadComponents != nullptr) { pLoadComponents->push_back(pComponent); } loadComponents.push_back(pComponent); BEATS_ASSERT(uComponentStartPos + uComponentDataSize == dataProxy.GetReadPos(), _T("Component Data Not Match!\nGot an error when import data for component %x %s instance id %d\nRequired size: %d, Actual size: %d"), uGuid, pComponent->GetClassStr(), uId, uComponentDataSize, dataProxy.GetReadPos() - uComponentStartPos); dataProxy.SetReadPos(uComponentStartPos + uComponentDataSize); } BEATS_ASSERT(dataProxy.GetReadPos() - uFileStartPos == uFileDataLength, _T("File Data NOT Match!\nGot an error when import data for file %d Required size:%d Actual size %d"), uFileId, uFileDataLength, dataProxy.GetReadPos() - uFileStartPos); dataProxy.SetBuffer(nullptr, 0, false); ResolveDependency(); SetLoadPhaseFlag(bOriginalLoadPhase); // After all component instance's value is read, we call each's load function. for (size_t i = 0; i < loadComponents.size(); ++i) { loadComponents[i]->Load(); } m_loadedFiles.push_back(uFileId); BEYONDENGINE_CHECK_HEAP; } }
void CPlayerPrefs::Load() { if (m_strSavePath.empty()) { m_strSavePath = CResourceManager::GetInstance()->GetPersistentDataPath().append(_T("/")).append(_T("PlayerPrefs")); } if (CFilePathTool::GetInstance()->Exists(m_strSavePath.c_str())) { CSerializer serializer; serializer.Serialize(m_strSavePath.c_str()); uint32_t uMapSize = 0; serializer >> uMapSize; for (uint32_t i = 0; i < uMapSize; ++i) { TString strKey; TString strValue; serializer >> strKey; serializer >> strValue; m_dataMap[strKey] = strValue; } }
bool ScriptManager::loadFromMemory(const std::string& name, const void* data, size_t len, ScriptType type) { std::string lower; std::transform(name.begin(), name.end(), std::back_inserter(lower), ::tolower); if (type == Type_Autodetect) { if (lower.substr(lower.size() - 4) == ".asb") type = Type_Bytecode; else if (lower.substr(lower.size() - 3) == ".as") type = Type_Text; else return false; } bool reload = mScripts.count(lower) > 0; std::list<asIScriptObject*> changes; asIScriptModule* module = mEngine->GetModule(lower.c_str(), asGM_ONLY_IF_EXISTS); CSerializer serial; if (reload && module) { for (auto& reg : mSerializers) serial.AddUserType(reg.second(), reg.first); for (auto it = mChangeNotice.begin(); it != mChangeNotice.end();) { if (it->second.WeakRef->Get()) { it->second.WeakRef->Release(); it = mChangeNotice.erase(it); continue; } auto* obj = it->first; if (obj->GetObjectType()->GetModule() == module) { serial.AddExtraObjectToStore(obj); changes.push_back(it->first); } ++it; } serial.Store(module); } BytecodeStore bcode; if (type == Type_Text) { static const char* scratchName = "!!ScratchSpace!!"; CScriptBuilder builder; for (auto& def : mDefines) builder.DefineWord(def.c_str()); builder.StartNewModule(mEngine, scratchName); for (auto& callback : mPreLoadCallbacks) if (!callback.second(builder.GetModule())) { mEngine->DiscardModule(scratchName); return false; } builder.AddSectionFromMemory(lower.c_str(), (const char*)data, len); int r = builder.BuildModule(); if (r < 0) { #ifndef NDEBUG puts(ASException::GetMessage(r)); #endif return false; } #ifdef NDEBUG builder.GetModule()->SaveByteCode(&bcode, true); #else builder.GetModule()->SaveByteCode(&bcode, false); #endif mEngine->DiscardModule(scratchName); } else { bcode = BytecodeStore((const char*)data, len); } if (module) module->Discard(); module = mEngine->GetModule(lower.c_str(), asGM_ALWAYS_CREATE); // FIXME? Preload callbacks can not act on bytecode anyway /* if (type == Type_Bytecode) for (auto& callback : mPreLoadCallbacks) if (!callback.second(module)) { module->Discard(); return false; } */ int r = module->LoadByteCode(&bcode); if (r < 0) { module->Discard(); return false; } module->BindAllImportedFunctions(); if (mScripts.count(lower) == 0) { mScripts[lower].Name = name; mScripts[lower].DirectLoad = true; } if (reload) { serial.Restore(module); for (auto& it : changes) { auto* newObj = (asIScriptObject*)serial.GetPointerToRestoredObject(it); auto notice = mChangeNotice[it]; mChangeNotice.erase(it); notice.WeakRef->Release(); notice.Callback(newObj); } mEngine->GarbageCollect(asGC_FULL_CYCLE); } return true; }
bool CSkin::Load() { bool bRet = false; BEATS_ASSERT(!IsLoaded(), _T("Can't Load a skin which is already loaded!")); // Load From File CSerializer serializer(_T("..\\Resource\\skin\\org.skin")); CSerializer tmpVerticesBufferPos, tmpVerticesBufferUV; CSerializer indexBuffer; size_t uVertexCount = 0; serializer >> uVertexCount; m_uVertexCount = uVertexCount; m_vertices = new CVertexPTB[uVertexCount]; float x, y, z; float u,v; for (size_t i = 0; i < uVertexCount; ++i) { ESkeletonBoneType bone, bone1, bone2, bone3; float weight, weight1, weight2,weight3; serializer >> x >> y >> z >> u >> v; serializer >> bone; serializer >> weight; serializer >> bone1; serializer >> weight1; serializer >> bone2; serializer >> weight2; serializer >> bone3; serializer >> weight3; CVertexPTB &vertex = m_vertices[i]; kmVec3Fill(&vertex.position,x,y,z); vertex.tex = CTex(u,v); vertex.bones = CIVector4(bone, bone1, bone2, bone3); kmVec4Fill(&vertex.weights,weight,weight1,weight2,weight3); #ifdef _DEBUG float sum = weight + weight1 + weight2+weight3; BEATS_ASSERT(sum < 1.01F, _T("Weight can't be greater than 1.01F, cur Value : %f!"), sum); BEATS_WARNING(sum > 0.99F, _T("Weight can't be smaller than 0.99F, cur Value : %f!"), sum); #endif } for (size_t i = 0; i < uVertexCount; ++i) { indexBuffer << (short)i; } CRenderer* pRenderer = CRenderer::GetInstance(); pRenderer->GenVertexArrays(1, &m_uVAO); pRenderer->GenBuffers(2, m_uVBO); #ifndef SW_SKEL_ANIM buildVBOVertex(m_vertices, m_uVertexCount*sizeof(CVertexPTB)); BEATS_SAFE_DELETE_ARRAY(m_vertices); #endif buildVBOIndex(indexBuffer.GetBuffer(), indexBuffer.GetWritePos()); buildVAO(); SetLoadedFlag(true); return bRet; }
void ExportLanguage() { std::map<uint32_t, std::map<ELanguageType, TString> > languageServerErrCodeMap; ReadServerErrCodeFile(languageServerErrCodeMap); std::map<TString, std::map<ELanguageType, TString> >& languageMap = CLanguageManager::GetInstance()->GetLanguageMap(); // 1. Export Bin File. CSerializer fileData; for (int i = 0; i < eLT_Count; ++i) { fileData << languageMap.size(); for (auto iter = languageMap.begin(); iter != languageMap.end(); ++iter) { auto subIter = iter->second.find((ELanguageType)i); if (subIter != iter->second.end()) { fileData << subIter->second; } else { fileData << iter->first; } } bool bRet = false; for (auto iter : languageServerErrCodeMap) { auto subIter = iter.second.find((ELanguageType)i); if (subIter != iter.second.end()) { if (!bRet) { fileData << languageServerErrCodeMap.size(); bRet = true; } fileData << iter.first; fileData << iter.second[(ELanguageType)i]; } } TString strFilePath = CResourceManager::GetInstance()->GetResourcePath(eRT_Language); strFilePath.append(_T("/")).append(pszLanguageTypeString[i]).append(_T(".bin")); fileData.Deserialize(strFilePath.c_str(), _T("wb+")); fileData.Reset(); } //2. Export enum file. std::string content; content.append("#ifndef BEYONDENGINEEDITOR_LANGUAGEENUM_H__INCLUDE\n#define BEYONDENGINEEDITOR_LANGUAGEENUM_H__INCLUDE\n").append("\nenum ELanguageTextType\n{\n"); for (auto iter = languageMap.begin(); iter != languageMap.end(); iter++) { content.append(" ").append(iter->first.c_str()).append(",\n"); } content.append("\n eL_Count,\n").append(" eL_Force32Bit = 0xFFFFFFFF\n};\n"); content.append("#define LUA_LANGUAGE_MAP(LM)\\\n"); int32_t nCounter = 0; for (auto iter = languageMap.begin(); iter != languageMap.end(); ++iter) { TCHAR szValueBuffer[32]; _stprintf(szValueBuffer, "%d", nCounter++); content.append(" ").append("LM(").append(iter->first.c_str()).append(",").append(szValueBuffer).append(")\\\n"); } content.append("\n#endif"); fileData.Reset(); fileData << content; fileData.SetWritePos(fileData.GetWritePos() - 1);// back scape the 0 in the string end. bool bFileTheSame = false; const TString strHeaderFilePath = CResourceManager::GetInstance()->GetResourcePath(eRT_SourceCode) + _T("/Language/Language.h"); if (CFilePathTool::GetInstance()->Exists(strHeaderFilePath.c_str())) { CSerializer tmpData(strHeaderFilePath.c_str(), "rb"); if (tmpData.GetWritePos() == fileData.GetWritePos()) { CMD5 tmpMD5(tmpData.GetBuffer(), tmpData.GetWritePos()); CMD5 currentMD5(fileData.GetBuffer(), fileData.GetWritePos()); bFileTheSame = tmpMD5 == currentMD5; } } if (!bFileTheSame) { fileData.Deserialize(strHeaderFilePath.c_str(), _T("wb+")); } //3. Export txt file. for (int i = 0; i < eLT_Count; ++i) { bool bHasData = false; fileData.Reset(); for (auto iter = languageMap.begin(); iter != languageMap.end(); ++iter) { auto subIter = iter->second.find((ELanguageType)i); if (subIter != iter->second.end()) { TString strData = (TString)(wxString::FromUTF8(subIter->second.c_str())); if (!bHasData && !strData.empty()) { bHasData = true; } fileData << strData; fileData.SetWritePos(fileData.GetWritePos() - 1); } fileData << "\n"; fileData.SetWritePos(fileData.GetWritePos() - 1); } if (bHasData) { TString strFilePath = CResourceManager::GetInstance()->GetResourcePath(eRT_Resource); strFilePath.append(_T("/")).append(pszLanguageTypeString[i]).append(_T(".txt")); fileData.Deserialize(strFilePath.c_str(), _T("wt+")); } } fileData.Reset(); const std::map<TString, TString>& languageTagMap = CLanguageManager::GetInstance()->GetLanguageTagMap(); for (auto iter = languageTagMap.begin(); iter != languageTagMap.end(); ++iter) { TString strData = (TString)(wxString::FromUTF8(iter->second.c_str())); fileData << strData; fileData.SetWritePos(fileData.GetWritePos() - 1); fileData << "\n"; fileData.SetWritePos(fileData.GetWritePos() - 1); } TString strFilePath = CResourceManager::GetInstance()->GetResourcePath(eRT_Resource); strFilePath.append(_T("/")).append("Tag").append(_T(".txt")); fileData.Deserialize(strFilePath.c_str(), _T("wt+")); fileData.Reset(); for (auto iter = languageMap.begin(); iter != languageMap.end(); ++iter) { TString strData = (TString)(wxString::FromUTF8(iter->first.c_str())); fileData << strData; fileData.SetWritePos(fileData.GetWritePos() - 1); fileData << "\n"; fileData.SetWritePos(fileData.GetWritePos() - 1); } strFilePath = CResourceManager::GetInstance()->GetResourcePath(eRT_Resource); strFilePath.append(_T("/")).append(_T("Enum.txt")); fileData.Deserialize(strFilePath.c_str(), _T("wt+")); }
void CComponentProxyManager::Export(const TCHAR* pSavePath, std::function<bool(uint32_t, CComponentProxy*)> exportCallback) { m_bExportingPhase = true; BEATS_ASSERT(pSavePath != NULL); static CSerializer serializer; serializer.Reset(); serializer << COMPONENT_SYSTEM_VERSION; serializer << GetComponentTemplateMap()->size(); CComponentProjectDirectory* pRootProject = m_pProject->GetRootDirectory(); pRootProject->Serialize(serializer); serializer << m_pProject->GetStartFile(); m_uOperateProgress = 0; uint32_t uFileCount = (uint32_t)(m_pProject->GetFileList()->size()); serializer << uFileCount; for (uint32_t i = 0; i < uFileCount; ++i) { const TString strFileName = CFilePathTool::GetInstance()->FileName(m_pProject->GetComponentFileName(i).c_str()); m_strCurrOperateFile = strFileName; serializer << strFileName; uint32_t uComponentCount = 0; uint32_t uWritePos = serializer.GetWritePos(); serializer << uWritePos;// File Start pos. serializer << 12;// File size placeholder. serializer << uComponentCount; // component count place holder const std::map<uint32_t, std::map<uint32_t, std::set<uint32_t> > >* pFileToComponent = m_pProject->GetFileToComponentMap(); auto iter = pFileToComponent->find(i); BEATS_ASSERT(iter != pFileToComponent->end(), _T("File: %s\ndoes not have a component!"), strFileName.c_str()); if (iter != pFileToComponent->end()) { std::vector<uint32_t>::iterator iterFile = std::find(m_loadedFiles.begin(), m_loadedFiles.end(), i); if (iterFile != m_loadedFiles.end()) { for (auto subIter = iter->second.begin(); subIter != iter->second.end(); ++subIter) { for (auto idIter = subIter->second.begin(); idIter != subIter->second.end(); ++idIter) { uint32_t uComponentId = *idIter; CComponentProxy* pProxy = static_cast<CComponentProxy*>(CComponentProxyManager::GetInstance()->GetComponentInstance(uComponentId)); if (pProxy) { if (ExportComponentProxy(i, pProxy, serializer, exportCallback)) { m_refreshFileList.insert(*iterFile); } ++uComponentCount; } else { BEATS_ASSERT(false, _T("Can't find proxy with GUID 0x%x id %d, have you removed that class in code?"), m_pProject->QueryComponentGuid(uComponentId), uComponentId); } } } } else { std::vector<CComponentBase*> vecComponents; // Don't create instance in LoadFile when exporting. BEATS_ASSERT(m_bCreateInstanceWithProxy); m_bCreateInstanceWithProxy = false; m_pIdManager->Lock(); LoadFile(i, &vecComponents); iterFile = std::find(m_loadedFiles.begin(), m_loadedFiles.end(), i); BEATS_ASSERT(iterFile != m_loadedFiles.end(), _T("Load file index %d failed!"), i); for (uint32_t j = 0; j < vecComponents.size(); ++j) { CComponentProxy* pProxy = static_cast<CComponentProxy*>(vecComponents[j]); if (ExportComponentProxy(i, pProxy, serializer, exportCallback)) { m_refreshFileList.insert(*iterFile); } ++uComponentCount; } ReSaveFreshFile(); // Don't call CloseFile, because we have nothing to do with proxy's host component. for (uint32_t j = 0; j < vecComponents.size(); ++j) { if (vecComponents[j]->GetId() != 0xFFFFFFFF) { CComponentProxyManager::GetInstance()->UnregisterInstance(vecComponents[j]); CComponentProxyManager::GetInstance()->GetIdManager()->RecycleId(vecComponents[j]->GetId()); } BEATS_SAFE_DELETE(vecComponents[j]); } m_loadedFiles.erase(iterFile); m_pIdManager->UnLock(); m_bCreateInstanceWithProxy = true;// Restore. } uint32_t uCurWritePos = serializer.GetWritePos(); uint32_t uFileDataSize = uCurWritePos - uWritePos; serializer.SetWritePos(uWritePos + sizeof(uint32_t));// Skip file start pos. serializer << uFileDataSize; serializer << uComponentCount; serializer.SetWritePos(uCurWritePos); } m_uOperateProgress = uint32_t((i + 1) * 100.f / uFileCount); } BEATS_ASSERT(m_uOperateProgress == 100); m_strCurrOperateFile.clear(); serializer.Deserialize(pSavePath); m_bExportingPhase = false; }