FString FChunkManifestGenerator::CreateCookerFileOrderString(const TMap<FName, FAssetData*>& InAssetData, const TArray<FName>& InMaps) { FString FileOrderString; TArray<FAssetData*> TopLevelNodes; for (auto Asset : InAssetData) { auto PackageName = Asset.Value->PackageName; TArray<FName> Referencers; AssetRegistry.GetReferencers(PackageName, Referencers); bool bIsTopLevel = true; bool bIsMap = InMaps.Contains(PackageName); if (!bIsMap && Referencers.Num() > 0) { for (auto ReferencerName : Referencers) { if (InAssetData.Contains(ReferencerName)) { bIsTopLevel = false; break; } } } if (bIsTopLevel) { if (bIsMap) { TopLevelNodes.Insert(Asset.Value, 0); } else { TopLevelNodes.Insert(Asset.Value, TopLevelNodes.Num()); } } } TArray<FName> FileOrder; TArray<FName> EncounteredNames; for (auto Asset : TopLevelNodes) { AddAssetToFileOrderRecursive(Asset, FileOrder, EncounteredNames, InAssetData, InMaps); } int32 CurrentIndex = 0; for (auto PackageName : FileOrder) { auto Asset = InAssetData[PackageName]; bool bIsMap = InMaps.Contains(Asset->PackageName); auto Filename = FPackageName::LongPackageNameToFilename(Asset->PackageName.ToString(), bIsMap ? FPackageName::GetMapPackageExtension() : FPackageName::GetAssetPackageExtension()); ConvertFilenameToPakFormat(Filename); auto Line = FString::Printf(TEXT("\"%s\" %i\n"), *Filename, CurrentIndex++); FileOrderString.Append(Line); } return FileOrderString; }
void FSlateWindowHelper::ArrangeWindowToFront( TArray< TSharedRef<SWindow> >& Windows, const TSharedRef<SWindow>& WindowToBringToFront ) { Windows.Remove(WindowToBringToFront); if ((Windows.Num() == 0) || WindowToBringToFront->IsTopmostWindow()) { Windows.Add(WindowToBringToFront); } else { bool PerformedInsert = false; for (int WindowIndex = Windows.Num() - 1; WindowIndex >= 0; --WindowIndex) { if (!Windows[WindowIndex]->IsTopmostWindow()) { Windows.Insert(WindowToBringToFront, WindowIndex + 1); PerformedInsert = true; break; } } if (!PerformedInsert) { Windows.Insert(WindowToBringToFront, 0); } } }
/** * Recursively look for `TargetItem` in `InsertInto` and any of the descendants. * Insert `ItemToInsert` relative to the target. * Relative positioning dictated by `RelativeLocation`. * * @return true when successful. */ static bool InsertRecursive(TArray< TSharedPtr< FTestData > >& InsertInto, const TSharedRef<FTestData>& ItemToInsert, const TSharedRef<FTestData>& TargetItem, EItemDropZone RelativeLocation) { const int32 TargetIndex = InsertInto.Find(TargetItem); if (TargetIndex != INDEX_NONE) { if (RelativeLocation == EItemDropZone::AboveItem) { InsertInto.Insert(ItemToInsert, TargetIndex); } else if (RelativeLocation == EItemDropZone::BelowItem) { InsertInto.Insert(ItemToInsert, TargetIndex + 1); } else { ensure(RelativeLocation == EItemDropZone::OntoItem); InsertInto[TargetIndex]->Children.Insert(ItemToInsert, 0); } return true; } // Did not successfully remove an item. Try all the children. for (int32 ItemIndex = 0; ItemIndex < InsertInto.Num(); ++ItemIndex) { if (InsertRecursive(InsertInto[ItemIndex]->Children, ItemToInsert, TargetItem, RelativeLocation)) { return true; } } return false; }
/** * This function parses the Json response after uploading the save file to obtain the * URL of the save file. * * @param JsonString Json string to parse * @param PlayerControllerId Player controller ID of the player who is saving the file * */ void CloudyWebConnectorImpl::ReadAndStoreSaveFileURL(FString JsonString, int32 PlayerControllerId) { JsonString = JsonString.Replace(TEXT("["), TEXT("")); JsonString = JsonString.Replace(TEXT("]"), TEXT("")); TSharedPtr<FJsonObject> JsonObject = MakeShareable(new FJsonObject()); TSharedRef<TJsonReader<TCHAR>> JsonReader = TJsonReaderFactory<TCHAR>::Create(JsonString); FJsonSerializer::Deserialize(JsonReader, JsonObject); // More player controllers than the TArray size if (PlayerControllerId >= SaveFileUrls.Num()) { SaveFileUrls.AddUninitialized(PlayerControllerId - SaveFileUrls.Num() + 1); } if (JsonObject->HasField("saved_file")) { UE_LOG(CloudyWebConnectorLog, Error, TEXT("Json saved_file field found.")); SaveFileUrls.Insert(JsonObject->GetStringField("saved_file"), PlayerControllerId); } else { UE_LOG(CloudyWebConnectorLog, Error, TEXT("Json saved_file field NOT found.")); SaveFileUrls.Insert("", PlayerControllerId); } }
void CMapGridPainter::AddRegion (const CVector &vCenter, Metric rWidth, Metric rHeight) // AddRegion // // Adds a rectangular region to paint. We combine this appropriately with any // previously added regions. { int x, y; Metric rHalfWidth = 0.5 * rWidth; Metric rHalfHeight = 0.5 * rHeight; int xFrom = (int)floor((vCenter.GetX() - rHalfWidth) / GRID_SIZE); int xTo = (int)floor((vCenter.GetX() + rHalfWidth) / GRID_SIZE); int yFrom = (int)floor((vCenter.GetY() - rHalfHeight) / GRID_SIZE); int yTo = (int)floor((vCenter.GetY() + rHalfHeight) / GRID_SIZE); // Null case if (xFrom == xTo || yFrom == yTo) return; // Start with vertical lines TArray<SLine> NewLines; for (x = xFrom; x <= xTo; x++) { SLine *pNewLine = NewLines.Insert(); pNewLine->xyKey = x; pNewLine->xyFrom = yFrom; pNewLine->xyTo = yTo; } AddLines(NewLines, &m_VertLines); // Add horizontal lines NewLines.DeleteAll(); for (y = yFrom; y <= yTo; y++) { SLine *pNewLine = NewLines.Insert(); pNewLine->xyKey = y; pNewLine->xyFrom = xFrom; pNewLine->xyTo = xTo; } AddLines(NewLines, &m_HorzLines); m_bRecalcNeeded = true; }
void CSystemCreateStats::AddLabelExpansion (const CString &sAttributes, const CString &sPrefix) // AddLabelExpansion // // Expands and adds the given attributes to the label counter { int i; TArray<CString> Attribs; ParseAttributes(sAttributes, &Attribs); // Add each of the attributes alone (and make a list of permutations) TArray<CString> Permutable; for (i = 0; i < Attribs.GetCount(); i++) { if (m_PermuteAttribs.Find(Attribs[i])) Permutable.Insert(Attribs[i]); else AddEntry(Attribs[i]); } // Now add all permutations if (Permutable.GetCount() >= 1) AddEntryPermutations(NULL_STR, Permutable, 0); }
ALERROR CLevelTableOfItemGenerators::LoadFromXML (SDesignLoadCtx &Ctx, CXMLElement *pDesc) // LoadFromXML // // Load table from XML { int i; ALERROR error; for (i = 0; i < pDesc->GetContentElementCount(); i++) { CXMLElement *pEntry = pDesc->GetContentElement(i); SEntry *pNewEntry = m_Table.Insert(); pNewEntry->sLevelFrequency = pEntry->GetAttribute(LEVEL_FREQUENCY_ATTRIB); pNewEntry->Count.LoadFromXML(pEntry->GetAttribute(COUNT_ATTRIB)); if (pNewEntry->Count.IsEmpty()) pNewEntry->Count.SetConstant(1); if (error = IItemGenerator::CreateFromXML(Ctx, pEntry, &pNewEntry->pEntry)) return error; } m_iComputedLevel = -1; return NOERROR; }
void CComplexArea::AddRect (TArray<SRect> &Array, int x, int y, int cxWidth, int cyHeight, int iRotation) // AddRect // // Adds the rect { int i; if (cxWidth <= 0 || cyHeight <= 0) return; // See if we already have a rect like this for (i = 0; i < Array.GetCount(); i++) { SRect &Test = Array[i]; if (Test.x == x && Test.y == y && Test.iRotation == iRotation && Test.cxWidth == cxWidth && Test.cyHeight == cyHeight) return; } // Add it SRect *pRect = Array.Insert(); pRect->x = x; pRect->y = y; pRect->cxWidth = cxWidth; pRect->cyHeight = cyHeight; pRect->iRotation = (iRotation > 0 ? (iRotation % 360) : 0); // Add to bounds if (iRotation > 0) { int xLL = 0; int yLL = 0; int xLR, yLR; IntPolarToVector(iRotation, cxWidth, &xLR, &yLR); int xUL, yUL; IntPolarToVector(iRotation + 90, cyHeight, &xUL, &yUL); int xUR = xUL + xLR; int yUR = yUL + yLR; int xLeft = Min(Min(xLL, xLR), Min(xUL, xUR)); int xRight = Max(Max(xLL, xLR), Max(xUL, xUR)); int yTop = Max(Max(yLL, yLR), Max(yUL, yUR)); int yBottom = Min(Min(yLL, yLR), Min(yUL, yUR)); AddToBounds(x + xLeft, y + yTop, x + xRight, y + yBottom); } else AddToBounds(x, y + cyHeight, x + cxWidth, y); }
bool FTimespan::Parse( const FString& TimespanString, FTimespan& OutTimespan ) { // @todo gmp: implement stricter FTimespan parsing; this implementation is too forgiving. FString TokenString = TimespanString.Replace(TEXT("."), TEXT(":")); bool Negative = TokenString.StartsWith(TEXT("-")); TokenString.ReplaceInline(TEXT("-"), TEXT(":"), ESearchCase::CaseSensitive); TArray<FString> Tokens; TokenString.ParseIntoArray(Tokens, TEXT(":"), true); if (Tokens.Num() == 4) { Tokens.Insert(TEXT("0"), 0); } if (Tokens.Num() == 5) { OutTimespan.Assign(FCString::Atoi(*Tokens[0]), FCString::Atoi(*Tokens[1]), FCString::Atoi(*Tokens[2]), FCString::Atoi(*Tokens[3]), FCString::Atoi(*Tokens[4])); if (Negative) { OutTimespan.Ticks *= -1; } return true; } return false; }
void CSpaceObjectList::Subtract (const CSpaceObjectList &List) // Subtract // // Removes all objects in List from the current list { int i; // Mark all current objects int iCount = GetCount(); for (i = 0; i < iCount; i++) GetObj(i)->SetMarked(true); // Clear marks on all objects to remove for (i = 0; i < List.GetCount(); i++) List.GetObj(i)->SetMarked(false); // Create a new list with the remaining objects TArray<CSpaceObject *> NewList; for (i = 0; i < iCount; i++) if (GetObj(i)->IsMarked()) NewList.Insert(GetObj(i)); m_List.TakeHandoff(NewList); }
ALERROR CGroupOfDeviceGenerators::LoadFromXML (SDesignLoadCtx &Ctx, CXMLElement *pDesc) // LoadFromXML // // Load from XML { int i; ALERROR error; m_Count.LoadFromXML(pDesc->GetAttribute(COUNT_ATTRIB)); if (m_Count.IsEmpty()) m_Count.SetConstant(1); // Load either a <DeviceSlot> element or another device generator. for (i = 0; i < pDesc->GetContentElementCount(); i++) { CXMLElement *pEntry = pDesc->GetContentElement(i); if (strEquals(pEntry->GetTag(), DEVICE_SLOT_TAG)) { SSlotDesc *pSlotDesc = m_SlotDesc.Insert(); CItem::ParseCriteria(pEntry->GetAttribute(CRITERIA_ATTRIB), &pSlotDesc->Criteria); if (error = IDeviceGenerator::InitDeviceDescFromXML(Ctx, pEntry, &pSlotDesc->DefaultDesc)) return error; pSlotDesc->iMaxCount = pEntry->GetAttributeIntegerBounded(MAX_COUNT_ATTRIB, 0, -1, -1); } else { SEntry *pTableEntry = m_Table.Insert(); pTableEntry->iChance = pEntry->GetAttributeIntegerBounded(CHANCE_ATTRIB, 0, -1, 100); if (error = IDeviceGenerator::CreateFromXML(Ctx, pEntry, &pTableEntry->pDevice)) { pTableEntry->pDevice = NULL; return error; } } } return NOERROR; }
void CDatum::RegisterMarkProc (MARKPROC fnProc) // RegisterMarkProc // // Register a procedure that will mark data in use { g_MarkList.Insert(fnProc); }
void PropertyHandleToPropertyPath(const UClass* OwnerClass, const IPropertyHandle& InPropertyHandle, TArray<UProperty*>& PropertyPath) { PropertyPath.Add(InPropertyHandle.GetProperty()); TSharedPtr<IPropertyHandle> CurrentHandle = InPropertyHandle.GetParentHandle(); while (CurrentHandle.IsValid() && CurrentHandle->GetProperty() != nullptr) { PropertyPath.Insert(CurrentHandle->GetProperty(), 0); CurrentHandle = CurrentHandle->GetParentHandle(); } }
// This will insert a mount point at the head of the search chain (so it can overlap an existing mount point and win) void InsertMountPoint(const FString& RootPath, const FString& ContentPath) { // Make sure the content path is stored as a relative path, consistent with the other paths we have FString RelativeContentPath = IFileManager::Get().ConvertToRelativePath( *ContentPath ); // Make sure the path ends in a trailing path separator. We are expecting that in the InternalFilenameToLongPackageName code. if( !RelativeContentPath.EndsWith( TEXT( "/" ) ) ) { RelativeContentPath += TEXT( "/" ); } FPathPair Pair(RootPath, RelativeContentPath); ContentRootToPath.Insert(Pair, 0); ContentPathToRoot.Insert(Pair, 0); MountPointRootPaths.Add( RootPath ); // Let subscribers know that a new content path was mounted FPackageName::OnContentPathMounted().Broadcast( RootPath, ContentPath ); }
bool CDeviceClass::AccumulateEnhancements (CItemCtx &Device, CInstalledDevice *pTarget, TArray<CString> &EnhancementIDs, CItemEnhancementStack *pEnhancements) // AccumulateEnhancements // // If this device can enhance pTarget, then we add to the list of enhancements. { int i; bool bEnhanced = false; CInstalledDevice *pDevice = Device.GetDevice(); CSpaceObject *pSource = Device.GetSource(); // See if we can enhance the target device if (pDevice == NULL || (pDevice->IsEnabled() && !pDevice->IsDamaged())) { for (i = 0; i < m_Enhancements.GetCount(); i++) { // If this type of enhancement has already been applied, skip it if (!m_Enhancements[i].sType.IsBlank() && EnhancementIDs.Find(m_Enhancements[i].sType)) continue; // If we don't match the criteria, skip it. if (pSource && pTarget && !pSource->GetItemForDevice(pTarget).MatchesCriteria(m_Enhancements[i].Criteria)) continue; // Add the enhancement pEnhancements->Insert(m_Enhancements[i].Enhancement); bEnhanced = true; // Remember that we added this enhancement class if (!m_Enhancements[i].sType.IsBlank()) EnhancementIDs.Insert(m_Enhancements[i].sType); } } // Let sub-classes add their own if (OnAccumulateEnhancements(Device, pTarget, EnhancementIDs, pEnhancements)) bEnhanced = true; // Done return bEnhanced; }
FName BuildCurveName( TSharedPtr<FSectionKeyAreaNode> KeyAreaNode ) { FString CurveName; TSharedPtr<FSequencerDisplayNode> CurrentNameNode = KeyAreaNode; TArray<FString> NameParts; while ( CurrentNameNode.IsValid() ) { NameParts.Insert( CurrentNameNode->GetDisplayName().ToString(), 0); CurrentNameNode = CurrentNameNode->GetParent(); } return FName(*FString::Join(NameParts, TEXT(" - "))); }
void CSpaceObjectAddressResolver::InsertRef (DWORD dwObjID, CSpaceObject **ppAddr) // InsertRef // // Insert a reference { TArray<SEntry> *pList = m_List.SetAt(dwObjID); SEntry *pEntry = pList->Insert(); pEntry->pCtx = ppAddr; pEntry->pfnResolveProc = NULL; }
void CSpaceObjectAddressResolver::InsertRef (DWORD dwObjID, void *pCtx, PRESOLVEOBJIDPROC pfnResolveProc) // InsertRef // // Insert a reference { TArray<SEntry> *pList = m_List.SetAt(dwObjID); SEntry *pEntry = pList->Insert(); pEntry->pCtx = pCtx; pEntry->pfnResolveProc = pfnResolveProc; }
bool CAeonEngine::OpenTableDefinitions (void) // OpenTableDefinitions // // Opens and reads all tables in all volumes. Note that we have no idea what // could have happened since our last boot--someone could have copied files // all over the place. We make almost no assumptions. { CSmartLock Lock(m_cs); int i, j; CString sError; // Loop over all volumes and end up with a list of tables and volumes TSortMap<CString, TArray<CString>> Tables; for (i = 0; i < m_LocalVolumes.GetCount(); i++) { CString sVolume = m_LocalVolumes.GetVolume(i); TArray<CString> Dirs; fileGetFileList(fileAppend(m_LocalVolumes.GetPath(i), FILESPEC_TABLE_DIR_FILTER), FFL_FLAG_DIRECTORIES_ONLY | FFL_FLAG_RELATIVE_FILESPEC, &Dirs); for (j = 0; j < Dirs.GetCount(); j++) { TArray<CString> *pList = Tables.SetAt(Dirs[j]); pList->Insert(sVolume); } } // Open all tables for (i = 0; i < Tables.GetCount(); i++) { CString sName = Tables.GetKey(i); CAeonTable *pTable = new CAeonTable; if (!pTable->Open(GetProcessCtx(), &m_LocalVolumes, sName, Tables[i], &sError)) { Log(MSG_LOG_ERROR, strPattern("Unable to load %s: %s", sName, sError)); delete pTable; continue; } m_Tables.Insert(sName, pTable); } // Done return true; }
void CPlayerGameStats::OnKeyEvent (EEventTypes iType, CSpaceObject *pObj, DWORD dwCauseUNID) // OnKeyEvent // // Adds a key event involving an object { ASSERT(pObj); CSystem *pSystem = pObj->GetSystem(); if (pSystem == NULL) return; // Get the NodeID where the event happened CTopologyNode *pNode = pSystem->GetTopology(); if (pNode == NULL) return; const CString &sNodeID = pNode->GetID(); // Get the object's type CDesignType *pType = pObj->GetType(); if (pType == NULL) return; // Get the object's name DWORD dwNameFlags; CString sName = pObj->GetName(&dwNameFlags); // If the object name is the same as the type name then we don't bother // storing it in the event (to save memory) if (strEquals(sName, pType->GetTypeName())) { sName = NULL_STR; dwNameFlags = 0; } // Look for the list of events for this NodeID TArray<SKeyEventStats> *pEventList = m_KeyEventStats.Set(sNodeID); SKeyEventStats *pStats = pEventList->Insert(); pStats->iType = iType; pStats->dwTime = g_pUniverse->GetTicks(); pStats->dwObjUNID = pObj->GetType()->GetUNID(); pStats->sObjName = sName; pStats->dwObjNameFlags = dwNameFlags; pStats->dwCauseUNID = dwCauseUNID; }
CMultiverseNewsEntry *CMultiverseModel::GetNextNewsEntry (void) // GetNextNewsEntry // // Returns the next news entry to display. // // NOTE: We return a copy which the callers are responsible for freeing. { CSmartLock Lock(m_cs); int i; // First make a list of all available news entries TArray<CMultiverseNewsEntry *> Available; for (i = 0; i < m_News.GetCount(); i++) { CMultiverseNewsEntry *pEntry = m_News.GetEntry(i); // If we've already shown this entry, skip it. if (pEntry->IsShown()) continue; // If this entry does not match the collection criteria, then skip it. if (m_Collection.HasAnyUNID(pEntry->GetExcludedUNIDs())) continue; if (!m_Collection.HasAllUNIDs(pEntry->GetRequiredUNIDs())) continue; Available.Insert(pEntry); } // If none available, nothing if (Available.GetCount() == 0) return NULL; // Pick a random entry CMultiverseNewsEntry *pEntry = Available[mathRandom(0, Available.GetCount() - 1)]; // Mark the entry as having been shown m_News.ShowNews(pEntry); // return this entry return new CMultiverseNewsEntry(*pEntry); }
void FLevelViewportCommands::HandleNewStat(const FName& InStatName, const FName& InStatCategory, const FText& InStatDescription) { FString CommandName = InStatName.ToString(); if (CommandName.RemoveFromStart(TEXT("STATGROUP_")) || CommandName.RemoveFromStart(TEXT("STAT_"))) { // Trim the front to get our category name FString GroupCategory = InStatCategory.ToString(); if (!GroupCategory.RemoveFromStart(TEXT("STATCAT_"))) { GroupCategory.Empty(); } // If we already have an entry (which can happen if a category has changed [when loading older saved stat data]) or we don't have a valid category then skip adding if (!FInputBindingManager::Get().FindCommandInContext(this->GetContextName(), InStatName).IsValid() && !GroupCategory.IsEmpty()) { // Find or Add the category TArray< FShowMenuCommand >* ShowStatCommands = ShowStatCatCommands.Find(GroupCategory); if (!ShowStatCommands) { // New category means we'll need to resort ShowStatCatCommands.Add(GroupCategory); ShowStatCatCommands.KeySort(TLess<FString>()); ShowStatCommands = ShowStatCatCommands.Find(GroupCategory); } const int32 NewIndex = FindStatIndex(ShowStatCommands, CommandName); if (NewIndex != INDEX_NONE) { const FText DisplayName = FText::FromString(CommandName); FText DescriptionName = InStatDescription; FFormatNamedArguments Args; Args.Add(TEXT("StatName"), DisplayName); if (DescriptionName.IsEmpty()) { DescriptionName = FText::Format(NSLOCTEXT("UICommands", "StatShowCommandName", "Show {StatName} Stat"), Args); } TSharedPtr<FUICommandInfo> StatCommand = FUICommandInfoDecl(this->AsShared(), InStatName, FText::GetEmpty(), DescriptionName) .UserInterfaceType(EUserInterfaceActionType::ToggleButton); FLevelViewportCommands::FShowMenuCommand ShowStatCommand(StatCommand, DisplayName); ShowStatCommands->Insert(ShowStatCommand, NewIndex); NewStatCommandDelegate.Broadcast(ShowStatCommand.ShowMenuItem, ShowStatCommand.LabelOverride.ToString()); } } } }
/** * This function parses the Json response after uploading the save file to obtain the * URL of the save file. * * @param JsonString Json string to parse * @param PlayerControllerId Player controller ID of the player who is saving the file * */ void CloudyWebAPIImpl::ReadAndStoreSaveFileURL(FString JsonString, int32 PlayerControllerId) { JsonString = JsonString.Replace(TEXT("["), TEXT("")); JsonString = JsonString.Replace(TEXT("]"), TEXT("")); TSharedPtr<FJsonObject> JsonObject = MakeShareable(new FJsonObject()); TSharedRef<TJsonReader<TCHAR>> JsonReader = TJsonReaderFactory<TCHAR>::Create(JsonString); FJsonSerializer::Deserialize(JsonReader, JsonObject); // More player controllers than the TArray size if (PlayerControllerId >= SaveFileUrls.Num()) { SaveFileUrls.AddUninitialized(PlayerControllerId - InitialArraySize + 1); } SaveFileUrls.Insert(JsonObject->GetStringField("saved_file"), PlayerControllerId); }
void CEnergyFieldList::GetList (TArray<CEnergyField *> &List) // GetList // // Returns all the fields in an array { List.DeleteAll(); CEnergyField *pField = m_pFirst; while (pField) { if (!pField->IsDestroyed()) List.Insert(pField); pField = pField->GetNext(); } }
void FieldVariableDescriptor::MergeArrays(TArray<FieldVariableDescriptor> & dest, const TArray<FieldVariableDescriptor> & source) { // in case of a performance loss this function should be rewritten with dictionaries (maps) and hash codes for(int j = 1; j <= source.Length(); j++) { const FieldVariableDescriptor & fvd = source(j); int i; int cmp = 1; for(i = 1; i <= dest.Length(); i++) { cmp = fvd.Compare(dest(i)); if(cmp != 1) break; // found either the same entry or the point where this entry is to be inserted } if(cmp != 0) dest.Insert(i, fvd); } }
bool FOnlineUserCloudOculus::ReadUserFile(const FUniqueNetId& UserId, const FString& FileName) { auto LoggedInPlayerId = OculusSubsystem.GetIdentityInterface()->GetUniquePlayerId(0); if (!LoggedInPlayerId.IsValid() || UserId != *LoggedInPlayerId) { UE_LOG_ONLINE(Warning, TEXT("Can only read data for logged in player")); return false; } FString BucketName; FString Key; if (!(FileName.Split(SEPARATOR, &BucketName, &Key))) { BucketName = DefaultBucket; Key = FileName; } OculusSubsystem.AddRequestDelegate( ovr_CloudStorage_Load(TCHAR_TO_UTF8(*BucketName), TCHAR_TO_UTF8(*Key)), FOculusMessageOnCompleteDelegate::CreateLambda([this, BucketName, Key, LoggedInPlayerId, FileName](ovrMessageHandle Message, bool bIsError) { ovrCloudStorageDataHandle response = ovr_Message_GetCloudStorageData(Message); check(BucketName == UTF8_TO_TCHAR(ovr_CloudStorageData_GetBucket(response))); check(Key == UTF8_TO_TCHAR(ovr_CloudStorageData_GetKey(response))); if (bIsError) { UE_LOG_ONLINE(Warning, TEXT("Failed to Load: %s%s%s"), *BucketName, *SEPARATOR, *Key); } else { int64 BlobSize = ovr_CloudStorageData_GetDataSize(response); const void* RawBlob = ovr_CloudStorageData_GetData(response); TArray<uint8> Blob; Blob.Insert(static_cast<const uint8 *>(RawBlob), BlobSize, 0); ReadCache.Add(FileName, MoveTemp(Blob)); } TriggerOnReadUserFileCompleteDelegates(!bIsError, *LoggedInPlayerId, FileName); })); return true; }
CDatum CAeonView::ComputeColumns (CHexeProcess &Process, CDatum dRowData) // ComputeColumns // // Returns a new row struct containing any computed columns. { if (m_ComputedColumns.IsNil() || !m_ComputedColumns.CanInvoke()) return dRowData; // Compute columns. We should get back a struct of all new columns. TArray<CDatum> Args; Args.Insert(dRowData); CDatum dResult; CHexeProcess::ERunCodes iRun = Process.Run(m_ComputedColumns, Args, &dResult); switch (iRun) { case CHexeProcess::runOK: { // dResult is a struct containing zero or more columns CDatum dNewRowData(new CComplexStruct(dRowData)); dNewRowData.Append(dResult); return dNewRowData; } case CHexeProcess::runError: { CDatum dNewRowData(new CComplexStruct(dRowData)); dNewRowData.SetElement(FIELD_ERROR, strPattern("ERROR: %s", dResult.AsString())); return dNewRowData; } default: { CDatum dNewRowData(new CComplexStruct(dRowData)); dNewRowData.SetElement(FIELD_ERROR, ERR_COMPUTED_COLUMN); return dNewRowData; } } }
void SortTriangles_Random( int32 NumTriangles, const FSoftSkinVertex* Vertices, uint32* Indices ) { TArray<int32> Triangles; for( int32 i=0;i<NumTriangles;i++ ) { Triangles.Insert(i, i > 0 ? FMath::Rand() % i : 0); } // export new draw order TArray<uint32> NewIndices; NewIndices.Empty(NumTriangles*3); for( int TriIndex=0;TriIndex<NumTriangles;TriIndex++ ) { int32 tri = Triangles[TriIndex]; NewIndices.Add(Indices[tri*3+0]); NewIndices.Add(Indices[tri*3+1]); NewIndices.Add(Indices[tri*3+2]); } FMemory::Memcpy( Indices, NewIndices.GetData(), NewIndices.Num() * sizeof(uint32) ); }
void CTranscendenceWnd::DestroyIntroShips (void) // DestroyIntroShips // // Destroys all ships of the same class as the POV { int i; CShip *pShip = g_pUniverse->GetPOV()->AsShip(); if (pShip == NULL) return; // Destroy all ships of the current class CSystem *pSystem = pShip->GetSystem(); CShipClass *pClassToDestroy = pShip->GetClass(); TArray<CSpaceObject *> ShipsToDestroy; CSpaceObject *pOtherShip = NULL; for (i = 0; i < pSystem->GetObjectCount(); i++) { CSpaceObject *pObj = pSystem->GetObject(i); CShip *pShip; if (pObj && !pObj->IsInactive() && !pObj->IsVirtual() && (pShip = pObj->AsShip())) { if (pShip->GetClass() == pClassToDestroy) ShipsToDestroy.Insert(pObj); else if (pOtherShip == NULL) pOtherShip = pObj; } } // Destroy ships for (i = 0; i < ShipsToDestroy.GetCount(); i++) ShipsToDestroy[i]->Destroy(removedFromSystem, CDamageSource()); }
ICCItem *CCodeChain::CreateVectorGivenContent(TArray<int> vShape, CCLinkedList *pContentList) // CreateVectorGivenContent (new) // // Creates a vector with given shape and content { int i; CCVector *pVector; ICCItem *pItem; pItem = m_VectorPool.CreateItem(this); if (pItem->IsError()) return pItem; pItem->Reset(); pVector = dynamic_cast<CCVector *>(pItem); pVector->SetContext(this); pVector->SetShape(this, vShape); pItem = pContentList->GetFlattened(this, NULL); if (pItem->IsError()) { pVector->Discard(this); return pItem; }; CCLinkedList *pFlattenedContentList = dynamic_cast<CCLinkedList *>(pItem); TArray<double> vDataArray; for (i = 0; i < pFlattenedContentList->GetCount(); i++) { vDataArray.Insert(pFlattenedContentList->GetElement(i)->GetDoubleValue()); }; pVector->SetArrayData(this, vDataArray); // Done pFlattenedContentList->Discard(this); return pVector->Reference(); }