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;
}
