void CComponentProxyManager::SetCurrentViewFileId(uint32_t uCurViewFileId) { // Rebuild the m_proxyInCurScene m_proxyInCurScene.clear(); const std::map<uint32_t, std::map<uint32_t, std::set<uint32_t> > >* pFileToComponentMap = m_pProject->GetFileToComponentMap(); auto fileToComponentIter = pFileToComponentMap->find(uCurViewFileId); if (fileToComponentIter != pFileToComponentMap->end()) { for (auto subIter = fileToComponentIter->second.begin(); subIter != fileToComponentIter->second.end(); ++subIter) { for (auto idIter = subIter->second.begin(); idIter != subIter->second.end(); ++idIter) { uint32_t uComponentId = *idIter; BEATS_ASSERT(m_proxyInCurScene.find(uComponentId) == m_proxyInCurScene.end()); CComponentProxy* pProxy = static_cast<CComponentProxy*>(CComponentProxyManager::GetInstance()->GetComponentInstance(uComponentId)); // If the component is deleted in code, it is possible that proxy is null. BEATS_ASSERT(pProxy != NULL || GetComponentTemplate(m_pProject->QueryComponentGuid(uComponentId)) == NULL); if (pProxy != NULL) { m_proxyInCurScene[uComponentId] = pProxy; } } } } m_uCurrViewFileId = uCurViewFileId; }
TString CComponentProxyManager::QueryComponentName(uint32_t uGuid) const { TString strRet; std::map<uint32_t, TString>::const_iterator iter = m_abstractComponentNameMap.find(uGuid); if (iter != m_abstractComponentNameMap.end()) { strRet = iter->second; } else { CComponentBase* pComponent = GetComponentTemplate(uGuid); if (pComponent != NULL) { strRet = pComponent->GetClassStr(); } } return strRet; }
void FSCSDiff::OnSCSEditorUpdateSelectionFromNodes(const TArray<FSCSEditorTreeNodePtrType>& SelectedNodes) { FText InspectorTitle = FText::GetEmpty(); TArray<UObject*> InspectorObjects; InspectorObjects.Empty(SelectedNodes.Num()); for (auto NodeIt = SelectedNodes.CreateConstIterator(); NodeIt; ++NodeIt) { auto NodePtr = *NodeIt; if(NodePtr.IsValid() && NodePtr->CanEditDefaults()) { InspectorTitle = FText::FromString(NodePtr->GetDisplayString()); InspectorObjects.Add(NodePtr->GetComponentTemplate()); } } if( Inspector.IsValid() ) { SKismetInspector::FShowDetailsOptions Options(InspectorTitle, true); Inspector->ShowDetailsForObjects(InspectorObjects, Options); } }
void CComponentProxyManager::SaveToFile(const TCHAR* pszFileName, std::map<uint32_t, std::vector<CComponentProxy*>>& components) { rapidxml::xml_document<> doc; rapidxml::xml_node<>* pDecl = doc.allocate_node(rapidxml::node_declaration); rapidxml::xml_attribute<>* pDecl_ver = doc.allocate_attribute("version", "1.0"); pDecl->append_attribute(pDecl_ver); doc.append_node(pDecl); rapidxml::xml_node<>* pRootElement = doc.allocate_node(rapidxml::node_element, "Root"); doc.append_node(pRootElement); rapidxml::xml_node<>* pComponentListElement = doc.allocate_node(rapidxml::node_element, "Components"); pRootElement->append_node(pComponentListElement); for (std::map<uint32_t, std::vector<CComponentProxy*>>::iterator iter = components.begin(); iter != components.end(); ++iter) { rapidxml::xml_node<>* pComponentElement = doc.allocate_node(rapidxml::node_element, "Component"); char szGUIDHexStr[32] = {0}; sprintf(szGUIDHexStr, "0x%x", iter->first); pComponentElement->append_attribute(doc.allocate_attribute("GUID", doc.allocate_string(szGUIDHexStr))); pComponentElement->append_attribute(doc.allocate_attribute("Name", doc.allocate_string(GetComponentTemplate(iter->first)->GetClassStr()))); pComponentListElement->append_node(pComponentElement); for (uint32_t i = 0; i < iter->second.size(); ++i) { CComponentProxy* pProxy = static_cast<CComponentProxy*>(iter->second.at(i)); pProxy->Save(); pProxy->SaveToXML(pComponentElement, false); } } TString strOut; #if (BEYONDENGINE_PLATFORM == PLATFORM_WIN32) rapidxml::print(std::back_inserter(strOut), doc, 0); #endif std::ofstream out(pszFileName); out << strOut; out.close(); }
void CComponentProxyManager::LoadFile(uint32_t uFileId, std::vector<CComponentBase*>* pComponentContainer) { const TString& strFilePath = m_pProject->GetComponentFileName(uFileId); BEATS_ASSERT(strFilePath.length() > 0); if (CFilePathTool::GetInstance()->Exists(strFilePath.c_str())) { rapidxml::file<> fdoc(strFilePath.c_str()); rapidxml::xml_document<> doc; try { doc.parse<rapidxml::parse_default>(fdoc.data()); doc.m_pszFilePath = strFilePath.c_str(); } catch (rapidxml::parse_error &e) { TCHAR info[MAX_PATH]; _stprintf(info, _T("Load file :%s Failed! error :%s"), strFilePath.c_str(), e.what()); MessageBox(BEYONDENGINE_HWND, info, _T("Load File Failed"), MB_OK | MB_ICONERROR); } BEATS_ASSERT(std::find(m_loadedFiles.begin(), m_loadedFiles.end(), uFileId) == m_loadedFiles.end()); m_loadedFiles.push_back(uFileId); rapidxml::xml_node<>* pRootElement = doc.first_node("Root"); rapidxml::xml_node<>* pComponentListNode = pRootElement->first_node("Components"); if (pComponentListNode != NULL) { bool bRestoreLoadingPhase = CComponentInstanceManager::GetInstance()->IsInLoadingPhase(); CComponentInstanceManager::GetInstance()->SetLoadPhaseFlag(true); std::vector<CComponentProxy*> loadedProxyList; rapidxml::xml_node<>* pComponentElement = pComponentListNode->first_node("Component"); while (pComponentElement != NULL) { const char* pGuidStr = pComponentElement->first_attribute("GUID")->value(); char* pStopPos = NULL; int guid = strtoul(pGuidStr, &pStopPos, 16); BEATS_ASSERT(*pStopPos == 0, _T("Guid value %s is not a 0x value at file %s."), pGuidStr, strFilePath.c_str()); if (GetComponentTemplate(guid) == NULL) { CComponentProxyManager::GetInstance()->GetRefreshFileList().insert(uFileId); BEATS_ASSERT(false, _T("Can't create component with \nGUID 0x%x\nName %s\nFile id:%d Name:%s\nHave you removed this component class?"), guid, pComponentElement->first_attribute("Name")->value(), uFileId, strFilePath.c_str()); } else { rapidxml::xml_node<>* pInstanceElement = pComponentElement->first_node(); while (pInstanceElement != NULL) { int id = atoi(pInstanceElement->first_attribute("Id")->value()); BEATS_ASSERT(id != -1); CComponentProxy* pComponentProxy = NULL; if (strcmp(pInstanceElement->name(), "Instance") == 0) { pComponentProxy = down_cast<CComponentProxy*>(CreateComponent(guid, false, false, id, false, NULL, false)); } pComponentProxy->LoadFromXML(pInstanceElement); loadedProxyList.push_back(pComponentProxy); if (pComponentContainer != nullptr) { pComponentContainer->push_back(pComponentProxy); } pInstanceElement = pInstanceElement->next_sibling(); } } pComponentElement = pComponentElement->next_sibling("Component"); } ResolveDependency(); CComponentInstanceManager::GetInstance()->SetLoadPhaseFlag(bRestoreLoadingPhase); if (!CComponentProxyManager::GetInstance()->IsExporting()) { // Call component proxy's initialize means we have sync all value to host component, so we call host component's load function. for (size_t i = 0; i < loadedProxyList.size(); ++i) { loadedProxyList[i]->Initialize(); } for (size_t i = 0; i < loadedProxyList.size(); ++i) { CComponentInstance* pHostComponent = static_cast<CComponentProxy*>(loadedProxyList[i])->GetHostComponent(); if (pHostComponent != nullptr) { pHostComponent->Load(); } else { BEATS_ASSERT(m_bCreateInstanceWithProxy == false, "Only when m_bCreateInstanceWithProxy is set to false, we can't get the host component"); } } } } } }