static inline void PopValueImpl(const TArray<FOscDataElemStruct> & input, TArray<FOscDataElemStruct> & output, T & Value) { if(input.Num() > 0) { output.Reserve(input.Num() - 1); for(int32 i=1, n=input.Num(); i!=n; ++i) { output.Add(input[i]); } Value = input[0].GetValue<T>(); } else { output.Empty(); Value = FOscDataElemStruct().GetValue<T>(); } }
void FAnimationRuntime::CreateMaskWeights(TArray<FPerBoneBlendWeight> & BoneBlendWeights, const TArray<FInputBlendPose> &BlendFilters, const FBoneContainer& RequiredBones, const USkeleton* Skeleton) { if ( Skeleton ) { const TArray<FBoneIndexType> & RequiredBoneIndices = RequiredBones.GetBoneIndicesArray(); BoneBlendWeights.Empty(RequiredBoneIndices.Num()); BoneBlendWeights.AddZeroed(RequiredBoneIndices.Num()); // base mask bone for (int32 PoseIndex=0; PoseIndex<BlendFilters.Num(); ++PoseIndex) { const FInputBlendPose& BlendPose = BlendFilters[PoseIndex]; for (int32 BranchIndex=0; BranchIndex<BlendPose.BranchFilters.Num(); ++BranchIndex) { const FBranchFilter& BranchFilter = BlendPose.BranchFilters[BranchIndex]; int32 MaskBoneIndex = RequiredBones.GetPoseBoneIndexForBoneName(BranchFilter.BoneName); // how much weight increase Per depth float MaxWeight = (BranchFilter.BlendDepth > 0) ? 1.f : -1.f; float IncreaseWeightPerDepth = (BranchFilter.BlendDepth != 0) ? (1.f/((float)BranchFilter.BlendDepth)) : 1.f; // go through skeleton tree requiredboneindices for (int32 BoneIndex = 0; BoneIndex<RequiredBoneIndices.Num(); ++BoneIndex) { int32 MeshBoneIndex = RequiredBoneIndices[BoneIndex]; int32 Depth = RequiredBones.GetDepthBetweenBones(MeshBoneIndex, MaskBoneIndex); // if Depth == -1, it's not a child if( Depth != -1 ) { // when you write to buffer, you'll need to match with BasePoses BoneIndex FPerBoneBlendWeight& BoneBlendWeight = BoneBlendWeights[BoneIndex]; BoneBlendWeight.SourceIndex = PoseIndex; float BlendIncrease = IncreaseWeightPerDepth * (float)(Depth + 1); BoneBlendWeight.BlendWeight = FMath::Clamp<float>(BoneBlendWeight.BlendWeight + BlendIncrease, 0.f, 1.f); } } } } } }
bool FBuildPatchVerificationImpl::VerifyAgainstDirectory(TArray<FString>& OutDatedFiles, double& TimeSpentPaused) { bool bAllCorrect = true; OutDatedFiles.Empty(); TimeSpentPaused = 0; if (VerifyMode == EVerifyMode::FileSizeCheckAllFiles || VerifyMode == EVerifyMode::ShaVerifyAllFiles) { Manifest->GetTaggedFileList(InstallTags, RequiredFiles); } // Setup progress tracking double TotalBuildSizeDouble = Manifest->GetFileSize(RequiredFiles); double ProcessedBytes = 0; CurrentBuildPercentage = 0; // Select verify function bool bVerifySha = VerifyMode == EVerifyMode::ShaVerifyAllFiles || VerifyMode == EVerifyMode::ShaVerifyTouchedFiles; // For all files in the manifest, check that they produce the correct SHA1 hash, adding any that don't to the list for (const FString& BuildFile : RequiredFiles) { // Break if quitting if (FBuildPatchInstallError::HasFatalError()) { break; } // Get file details int64 BuildFileSize = Manifest->GetFileSize(BuildFile); // Verify the file CurrentFileWeight = BuildFileSize / TotalBuildSizeDouble; bool bFileOk = bVerifySha ? VerfiyFileSha(BuildFile, TimeSpentPaused) : VerfiyFileSize(BuildFile, TimeSpentPaused); if (bFileOk == false) { bAllCorrect = false; OutDatedFiles.Add(BuildFile); } ProcessedBytes += BuildFileSize; CurrentBuildPercentage = ProcessedBytes / TotalBuildSizeDouble; } return bAllCorrect && !FBuildPatchInstallError::HasFatalError(); }
void UInputComponent::RemoveActionBinding( const int32 BindingIndex ) { if (BindingIndex >= 0 && BindingIndex < ActionBindings.Num()) { const FInputActionBinding& BindingToRemove = ActionBindings[BindingIndex]; // Potentially need to clear some pairings if (BindingToRemove.bPaired) { TArray<int32> IndicesToClear; const EInputEvent PairedEvent = (BindingToRemove.KeyEvent == IE_Pressed ? IE_Released : IE_Pressed); for (int32 ActionIndex = 0; ActionIndex < ActionBindings.Num(); ++ActionIndex) { if (ActionIndex != BindingIndex) { const FInputActionBinding& ActionBinding = ActionBindings[ActionIndex]; if (ActionBinding.ActionName == BindingToRemove.ActionName) { // If we find another of the same key event then the pairing is intact so we're done if (ActionBinding.KeyEvent == BindingToRemove.KeyEvent) { IndicesToClear.Empty(); break; } // Otherwise we may need to clear the pairing so track the index else if (ActionBinding.KeyEvent == PairedEvent) { IndicesToClear.Add(ActionIndex); } } } } for (int32 ClearIndex = 0; ClearIndex < IndicesToClear.Num(); ++ClearIndex) { ActionBindings[IndicesToClear[ClearIndex]].bPaired = false; } } ActionBindings.RemoveAt(BindingIndex); } }
void FPIELoginSettingsInternal::Decrypt() { if (TokenBytes.Num() > 0) { const int64 PaddedEncryptedFileSize = Align(TokenBytes.Num(), FAES::AESBlockSize); if (PaddedEncryptedFileSize > 0 && PaddedEncryptedFileSize == TokenBytes.Num()) { TArray<uint8> TempArray; TempArray.Empty(PaddedEncryptedFileSize); TempArray.AddUninitialized(PaddedEncryptedFileSize); FMemory::Memcpy(TempArray.GetData(), TokenBytes.GetData(), PaddedEncryptedFileSize); // XOR Cipher int32 NumXors = PaddedEncryptedFileSize / sizeof(int32); int32* TempArrayPtr = (int32*)(TempArray.GetData()); for (int32 i = 0; i < NumXors; i++) { TempArrayPtr[i] = TempArrayPtr[i] ^ ONLINEPIE_XOR_KEY; } //FAES::DecryptData(TempArray.GetData(), PaddedEncryptedFileSize); // Validate the unencrypted data (stored size less than total data, null terminated character where it should be) int32 PasswordDataSize = TempArray[0]; int32 PasswordLength = PasswordDataSize / sizeof(TCHAR); TCHAR* Password = (TCHAR*)(TempArray.GetData() + 1); if (PasswordDataSize < TempArray.Num() && Password[PasswordLength - 1] == '\0') { Token = FString(Password); } else { Token.Empty(); TokenBytes.Empty(); } } } else { Token.Empty(); } }
void FAnimNode_BlendListBase::Evaluate(FPoseContext& Output) { SCOPE_CYCLE_COUNTER(STAT_AnimNativeBlendPoses); const int32 MaxNumPoses = BlendPose.Num(); //@TODO: This is currently using O(NumPoses) memory but doesn't need to if ((MaxNumPoses > 0) && (BlendPose.Num() == BlendWeights.Num())) { TArray<FPoseContext> FilteredPoseContexts; FilteredPoseContexts.Empty(MaxNumPoses); FTransformArrayA2** FilteredPoses = new FTransformArrayA2*[MaxNumPoses]; float* FilteredWeights = new float[MaxNumPoses]; int32 NumActivePoses = 0; for (int32 i = 0; i < BlendPose.Num(); ++i) { const float BlendWeight = BlendWeights[i]; if (BlendWeight > ZERO_ANIMWEIGHT_THRESH) { FPoseContext& CurrentPoseContext = *(new (FilteredPoseContexts) FPoseContext(Output)); FPoseLink& CurrentPose = BlendPose[i]; CurrentPose.Evaluate(CurrentPoseContext); FilteredPoses[NumActivePoses] = &(CurrentPoseContext.Pose.Bones); FilteredWeights[NumActivePoses] = BlendWeight; NumActivePoses++; } } FAnimationRuntime::BlendPosesTogether(NumActivePoses, (const FTransformArrayA2**)FilteredPoses, (const float*)FilteredWeights, Output.AnimInstance->RequiredBones, Output.Pose.Bones); delete[] FilteredPoses; delete[] FilteredWeights; } else { Output.ResetToRefPose(); } }
virtual bool Create(uint32 InNumQueuedThreads,uint32 StackSize = (32 * 1024),EThreadPriority ThreadPriority=TPri_Normal) override { // Make sure we have synch objects bool bWasSuccessful = true; check(SynchQueue == nullptr); SynchQueue = new FCriticalSection(); FScopeLock Lock(SynchQueue); // Presize the array so there is no extra memory allocated check(QueuedThreads.Num() == 0); QueuedThreads.Empty(InNumQueuedThreads); // Check for stack size override. if( OverrideStackSize > StackSize ) { StackSize = OverrideStackSize; } // Now create each thread and add it to the array for (uint32 Count = 0; Count < InNumQueuedThreads && bWasSuccessful == true; Count++) { // Create a new queued thread FQueuedThread* pThread = new FQueuedThread(); // Now create the thread and add it if ok if (pThread->Create(this,StackSize,ThreadPriority) == true) { QueuedThreads.Add(pThread); AllThreads.Add(pThread); } else { // Failed to fully create so clean up bWasSuccessful = false; delete pThread; } } // Destroy any created threads if the full set was not successful if (bWasSuccessful == false) { Destroy(); } return bWasSuccessful; }
TArray<FLayoutGeometry> SSplitter2x2::ArrangeChildrenForLayout( const FGeometry& AllottedGeometry ) const { check( Children.Num() == 4 ); TArray<FLayoutGeometry> Result; Result.Empty(Children.Num()); int32 NumNonCollapsedChildren = 0; FVector2D CoefficientTotal(0,0); // The allotted space for our children is our geometry minus a little space to show splitter handles const FVector2D SpaceAllottedForChildren = AllottedGeometry.Size - FVector2D(SplitterHandleSize,SplitterHandleSize); // The current offset that the next child should be positioned at. FVector2D Offset(0,0); for (int32 ChildIndex=0; ChildIndex < Children.Num(); ++ChildIndex) { const FSlot& CurSlot = Children[ChildIndex]; // Calculate the amount of space that this child should take up. // It is based on the current percentage of space it should take up which is defined by a user moving the splitters const FVector2D ChildSpace = SpaceAllottedForChildren * CurSlot.PercentageAttribute.Get(); // put them in their spot Result.Emplace(FSlateLayoutTransform(Offset), ChildSpace); // Advance to the next slot. If the child is collapsed, it takes up no room and does not need a splitter if( ChildIndex == 1 ) { // ChildIndex of 1 means we are starting the next column so reset the Y offset. Offset.Y = 0.0f; Offset += FVector2D( ChildSpace.X + SplitterHandleSize, 0); } else { Offset += FVector2D( 0, ChildSpace.Y + SplitterHandleSize ); } } return Result; }
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 UK2Node_CallArrayFunction::GetArrayTypeDependentPins(TArray<UEdGraphPin*>& OutPins) const { OutPins.Empty(); UFunction* TargetFunction = GetTargetFunction(); check(TargetFunction); const FString DependentPinMetaData = TargetFunction->GetMetaData(FBlueprintMetadata::MD_ArrayDependentParam); TArray<FString> TypeDependentPinNames; DependentPinMetaData.ParseIntoArray(TypeDependentPinNames, TEXT(","), true); for(TArray<UEdGraphPin*>::TConstIterator it(Pins); it; ++it) { UEdGraphPin* CurrentPin = *it; int32 ItemIndex = 0; if( CurrentPin && TypeDependentPinNames.Find(CurrentPin->PinName, ItemIndex) ) { OutPins.Add(CurrentPin); } } }
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) ); }
/** Calculates the step 1D cumulative distribution function for the given unnormalized probability distribution function. */ void CalculateStep1dCDF(const TArray<float>& PDF, TArray<float>& CDF, float& UnnormalizedIntegral) { CDF.Empty(PDF.Num()); float RunningUnnormalizedIntegral = 0; CDF.Add(0.0f); for (int32 i = 1; i < PDF.Num(); i++) { RunningUnnormalizedIntegral += PDF[i - 1]; CDF.Add(RunningUnnormalizedIntegral); } UnnormalizedIntegral = RunningUnnormalizedIntegral + PDF.Last(); if (UnnormalizedIntegral > 0.0f) { // Normalize the CDF for (int32 i = 1; i < CDF.Num(); i++) { CDF[i] /= UnnormalizedIntegral; } } check(CDF.Num() == PDF.Num()); }
// Called when the game starts or when spawned void AWorldSpawn::BeginPlay() { Super::BeginPlay(); UE_LOG(LogTemp, Warning, TEXT("BEGIN PLAY")); hex_list.clear(); chunk_triangles.Empty(); AActor* new_hex_obj = GetWorld()->SpawnActor<AActor>(hex_asset, FVector::ZeroVector, FRotator(0, -90, 0)); UStaticMeshComponent* mesh_component = Cast<UStaticMeshComponent>(new_hex_obj->GetComponentByClass(UStaticMeshComponent::StaticClass())); vertex_buffer = &mesh_component->StaticMesh->RenderData->LODResources[0].PositionVertexBuffer; index_buffer = mesh_component->StaticMesh->RenderData->LODResources[0].IndexBuffer.GetArrayView(); new_hex_obj->Destroy(); SetActorRotation(FRotator(0, -90, 0)); UE_LOG(LogTemp, Warning, TEXT("num_vertices: %d"), vertex_buffer->GetNumVertices()); fnoise.init(); gen_chunk(); }
void FDestructibleMeshEditorViewportClient::UpdateChunkSelection( TArray<int32> InSelectedChunkIndices ) { // Store the proxies in the ppol UnusedProxies.Append(SelectedChunks); // Clear selected chunks SelectedChunks.Empty(InSelectedChunkIndices.Num()); // make sure we have enough proxies to fill the selection array */ while(UnusedProxies.Num() < InSelectedChunkIndices.Num()) { UnusedProxies.Add(NewObject<UDestructibleChunkParamsProxy>()); } UDestructibleMesh* DestructibleMesh = DestructibleMeshEditorPtr.Pin()->GetDestructibleMesh(); UDestructibleFractureSettings* FractureSettings = DestructibleMesh->FractureSettings; TArray<UObject*> SelectedObjects; // Setup the selection array for (int32 i=0; i < InSelectedChunkIndices.Num(); ++i) { UDestructibleChunkParamsProxy* Proxy = UnusedProxies.Pop(); Proxy->DestructibleMesh = DestructibleMesh; Proxy->ChunkIndex = InSelectedChunkIndices[i]; Proxy->DestructibleMeshEditorPtr = DestructibleMeshEditorPtr; if (FractureSettings != NULL && FractureSettings->ChunkParameters.Num() > Proxy->ChunkIndex) { Proxy->ChunkParams = Proxy->DestructibleMesh->FractureSettings->ChunkParameters[Proxy->ChunkIndex]; } SelectedChunks.Add(Proxy); SelectedObjects.Add(Proxy); } FDestructibleMeshEditor* MeshEd = (FDestructibleMeshEditor*)DestructibleMeshEditorPtr.Pin().Get(); MeshEd->SetSelectedChunks(SelectedObjects); }
void FColorStructCustomization::OnColorPickerCancelled( FLinearColor OriginalColor ) { TArray<FString> PerObjectColors; for( int32 ColorIndex = 0; ColorIndex < SavedPreColorPickerColors.Num(); ++ColorIndex ) { if( bIsLinearColor ) { PerObjectColors.Add( SavedPreColorPickerColors[ColorIndex].ToString() ); } else { const bool bSRGB = false; FColor Color = SavedPreColorPickerColors[ColorIndex].ToFColor( bSRGB ); PerObjectColors.Add( Color.ToString() ); } } StructPropertyHandle->SetPerObjectValues( PerObjectColors ); PerObjectColors.Empty(); }
void GetObjectsWithAnyMarks(TArray<UObject *>& Results, EObjectMark Marks) { // We don't want to return any objects that are currently being background loaded unless we're using the object iterator during async loading. EObjectFlags ExclusionFlags = RF_Unreachable; if (!IsInAsyncLoadingThread()) { ExclusionFlags = EObjectFlags(ExclusionFlags | RF_AsyncLoading); } const TMap<const UObjectBase *, FObjectMark>& Map = MarkAnnotation.GetAnnotationMap(); Results.Empty(Map.Num()); for (TMap<const UObjectBase *, FObjectMark>::TConstIterator It(Map); It; ++It) { if (It.Value().Marks & Marks) { UObject* Item = (UObject*)It.Key(); if (!Item->HasAnyFlags(ExclusionFlags)) { Results.Add(Item); } } } }
void FOptionalPinManager::RebuildPropertyList(TArray<FOptionalPinFromProperty>& Properties, UStruct* SourceStruct) { // Save the old visibility TMap<FName, bool> OldVisibility; for (auto ExtraPropertyIt = Properties.CreateIterator(); ExtraPropertyIt; ++ExtraPropertyIt) { FOptionalPinFromProperty& PropertyEntry = *ExtraPropertyIt; OldVisibility.Add(PropertyEntry.PropertyName, PropertyEntry.bShowPin); } // Rebuild the property list Properties.Empty(); for (TFieldIterator<UProperty> It(SourceStruct, EFieldIteratorFlags::IncludeSuper); It; ++It) { UProperty* TestProperty = *It; if (CanTreatPropertyAsOptional(TestProperty)) { FOptionalPinFromProperty* Record = new (Properties) FOptionalPinFromProperty; Record->PropertyName = TestProperty->GetFName(); Record->PropertyFriendlyName = UEditorEngine::GetFriendlyName(TestProperty, SourceStruct); Record->PropertyTooltip = TestProperty->GetToolTipText(); // Get the defaults GetRecordDefaults(TestProperty, *Record); // If this is a refresh, propagate the old visibility if (Record->bCanToggleVisibility) { if (bool* pShowHide = OldVisibility.Find(Record->PropertyName)) { Record->bShowPin = *pShowHide; } } } } }
void FAnimationRuntime::FillUpSpaceBasesRefPose(const USkeleton* Skeleton, TArray<FTransform> &SpaceBaseRefPose) { check(Skeleton); const TArray<FTransform> & ReferencePose = Skeleton->GetReferenceSkeleton().GetRefBonePose(); SpaceBaseRefPose.Empty(ReferencePose.Num()); SpaceBaseRefPose.AddUninitialized(ReferencePose.Num()); // initialize to identity since some of them don't have tracks for(int Index=0; Index <SpaceBaseRefPose.Num(); ++Index) { int32 ParentIndex = Skeleton->GetReferenceSkeleton().GetParentIndex(Index); if(ParentIndex != INDEX_NONE) { SpaceBaseRefPose[Index] = ReferencePose[Index] * SpaceBaseRefPose[ParentIndex]; } else { SpaceBaseRefPose[Index] = ReferencePose[Index]; } } }
void FDragConnection::ValidateGraphPinList(TArray<UEdGraphPin*>& OutValidPins) { OutValidPins.Empty(StartingPins.Num()); for (TArray< TSharedRef<SGraphPin> >::TIterator PinIterator(StartingPins); PinIterator; ++PinIterator) { if (UEdGraphPin* StartingPinObj = (*PinIterator)->GetPinObj()) { //Check whether the list contains updated pin object references by checking its outer class type if ((StartingPinObj->GetOuter() == NULL) || !StartingPinObj->GetOuter()->IsA(UEdGraphNode::StaticClass())) { //This pin object reference is old. So remove it from the list. TSharedRef<SGraphPin> PinPtr = *PinIterator; StartingPins.Remove( PinPtr ); } else { OutValidPins.Add(StartingPinObj); } } } }
void UPaperSprite::Triangulate(const FSpritePolygonCollection& Source, TArray<FVector2D>& Target) { Target.Empty(); for (int32 PolygonIndex = 0; PolygonIndex < Source.Polygons.Num(); ++PolygonIndex) { const FSpritePolygon& SourcePoly = Source.Polygons[PolygonIndex]; if (SourcePoly.Vertices.Num() >= 3) { // Convert our format into one the triangulation library supports FClipSMPolygon ClipPolygon(0); for (int32 VertexIndex = 0; VertexIndex < SourcePoly.Vertices.Num() ; ++VertexIndex) { FClipSMVertex* ClipVertex = new (ClipPolygon.Vertices) FClipSMVertex; FMemory::Memzero(ClipVertex, sizeof(FClipSMVertex)); const FVector2D& SourceVertex = SourcePoly.Vertices[VertexIndex]; ClipVertex->Pos.X = SourceVertex.X; ClipVertex->Pos.Z = SourceVertex.Y; } ClipPolygon.FaceNormal = FVector(0.0f, -1.0f, 0.0f); // Attempt to triangulate this polygon TArray<FClipSMTriangle> GeneratedTriangles; if (TriangulatePoly(/*out*/ GeneratedTriangles, ClipPolygon)) { // Convert the triangles back to our 2D data structure for (int32 TriangleIndex = 0; TriangleIndex < GeneratedTriangles.Num(); ++TriangleIndex) { const FClipSMTriangle& Triangle = GeneratedTriangles[TriangleIndex]; new (Target) FVector2D(Triangle.Vertices[0].Pos.X, Triangle.Vertices[0].Pos.Z); new (Target) FVector2D(Triangle.Vertices[1].Pos.X, Triangle.Vertices[1].Pos.Z); new (Target) FVector2D(Triangle.Vertices[2].Pos.X, Triangle.Vertices[2].Pos.Z); } } } } }
/** Generates unit length, stratified and uniformly distributed direction samples in a hemisphere. */ void GenerateStratifiedUniformHemisphereSamples(int32 NumThetaSteps, int32 NumPhiSteps, FLMRandomStream& RandomStream, TArray<FVector4>& Samples, TArray<FVector2D>& Uniforms) { Samples.Empty(NumThetaSteps * NumPhiSteps); for (int32 ThetaIndex = 0; ThetaIndex < NumThetaSteps; ThetaIndex++) { for (int32 PhiIndex = 0; PhiIndex < NumPhiSteps; PhiIndex++) { const float U1 = RandomStream.GetFraction(); const float U2 = RandomStream.GetFraction(); const float Fraction1 = (ThetaIndex + U1) / (float)NumThetaSteps; const float Fraction2 = (PhiIndex + U2) / (float)NumPhiSteps; const float R = FMath::Sqrt(1.0f - Fraction1 * Fraction1); const float Phi = 2.0f * (float)PI * Fraction2; // Convert to Cartesian Samples.Add(FVector4(FMath::Cos(Phi) * R, FMath::Sin(Phi) * R, Fraction1)); Uniforms.Add(FVector2D(Fraction1, Fraction2)); } } }
void FInternationalization::GetTimeZonesIDs(TArray<FString>& TimeZonesIDs) { TimeZonesIDs.Empty(); #if UE_ENABLE_ICU UErrorCode ICUStatus = U_ZERO_ERROR; TSharedPtr<icu::StringEnumeration> StringEnumeration( icu::TimeZone::createEnumeration() ); TimeZonesIDs.Reserve( StringEnumeration->count(ICUStatus) ); const icu::UnicodeString* ICUString; do { ICUString = StringEnumeration->snext(ICUStatus); if(ICUString) { FString NativeString; ICUUtilities::Convert(*ICUString, NativeString); TimeZonesIDs.Add( NativeString ); } } while( ICUString ); #endif }
void FComponentTypeRegistryData::Tick(float) { bool bRequiresRefresh = bNeedsRefreshNextTick; bNeedsRefreshNextTick = false; if (PendingAssetData.Num() != 0) { FAssetRegistryModule& AssetRegistryModule = FModuleManager::LoadModuleChecked<FAssetRegistryModule>(TEXT("AssetRegistry")); TArray<FName> ClassNames; ClassNames.Add(UActorComponent::StaticClass()->GetFName()); TSet<FName> DerivedClassNames; AssetRegistryModule.Get().GetDerivedClassNames(ClassNames, TSet<FName>(), DerivedClassNames); for (auto Asset : PendingAssetData) { const FName BPParentClassName(GET_MEMBER_NAME_CHECKED(UBlueprint, ParentClass)); bool FoundBPNotify = false; for (TMap<FName, FString>::TConstIterator TagIt(Asset.TagsAndValues); TagIt; ++TagIt) { FString TagValue = Asset.TagsAndValues.FindRef(BPParentClassName); const FString ObjectPath = FPackageName::ExportTextPathToObjectPath(TagValue); FName ObjectName = FName(*FPackageName::ObjectPathToObjectName(ObjectPath)); if (DerivedClassNames.Contains(ObjectName)) { bRequiresRefresh = true; break; } } } PendingAssetData.Empty(); } if (bRequiresRefresh) { ForceRefreshComponentList(); } }
void AProject_152GameMode::ProcessWin(int32 InputExperience, int32 Currencytoadd) { AProject_152Character* MyCharTemp; MyCharTemp = Cast<AProject_152Character>(UGameplayStatics::GetPlayerCharacter(GetWorld(), 0)); TArray<int32> ItemIdArray; ItemIdArray.Empty(); /* for (int i = 0; i < CharactersInCombat.Num(); i++) { if (CharactersInCombat[i]->bIsHumanPlayer) { ItemIdArray.Add(CharactersInCombat[i]->ItemId); //CharactersInCombat[i]->AddExperience(InputExperience); } } for (int i = 0; i < ItemIdArray.Num(); i++) { for (int j = 0; j < MyCharTemp->ParentCombatCharacterInventoryArray.Num(); j++) { if (MyCharTemp->ParentCombatCharacterInventoryArray[j].ItemID == ItemIdArray[i]) { MyCharTemp->ParentCombatCharacterInventoryArray[j].Experience += InputExperience; CheckForLevelUP(MyCharTemp->ParentCombatCharacterInventoryArray[j]); } } } */ for (int k = 0; k < MyCharTemp->ParentCombatCharacterInventoryArray.Num(); k++) { MyCharTemp->ParentCombatCharacterInventoryArray[k].Experience += InputExperience; CheckForLevelUP(MyCharTemp->ParentCombatCharacterInventoryArray[k], k); } MyCharTemp->Currency += Currencytoadd; }
/** Create connectivity groups */ void CreateConnectivityGroups() { // Delete group list Groups.Empty(); // Reset group assignments for ( int32 i=0; i<Triangles.Num(); i++ ) { Triangles[i].Group = INDEX_NONE; } // Flood fill using connectivity info for ( ;; ) { // Find first triangle without group assignment int32 InitialTriangle = INDEX_NONE; for ( int32 i=0; i<Triangles.Num(); i++ ) { if ( Triangles[i].Group == INDEX_NONE ) { InitialTriangle = i; break; } } // No more unassigned triangles, flood fill is done if ( InitialTriangle == INDEX_NONE ) { break; } // Create group int32 GroupIndex = Groups.AddZeroed( 1 ); // Start flood fill using connectivity information FloodFillTriangleGroups( InitialTriangle, GroupIndex ); } }
bool FBuildPatchVerificationImpl::VerifyAgainstDirectory(TArray<FString>& OutDatedFiles, double& TimeSpentPaused) { bool bAllCorrect = true; OutDatedFiles.Empty(); TimeSpentPaused = 0; // Setup progress tracking double TotalBuildSizeDouble = Manifest->GetBuildSize(); double ProcessedBytes = 0; CurrentBuildPercentage = 0; // For all files in the manifest, check that they produce the correct SHA1 hash, adding any that don't to the list TArray<FString> BuildFiles; Manifest->GetFileList(BuildFiles); for (const FString& BuildFile : BuildFiles) { // Get file details int64 BuildFileSize = Manifest->GetFileSize(BuildFile); FSHAHashData BuildFileHash; bool bFoundHash = Manifest->GetFileHash(BuildFile, BuildFileHash); check(bFoundHash); // Chose the file to check FString FullFilename = SelectFullFilePath(BuildFile); // Verify the file CurrentFileWeight = BuildFileSize / TotalBuildSizeDouble; if (FBuildPatchUtils::VerifyFile(FullFilename, BuildFileHash, BuildFileHash, FBuildPatchFloatDelegate::CreateRaw(this, &FBuildPatchVerificationImpl::PerFileProgress), ShouldPauseDelegate, TimeSpentPaused) == 0) { bAllCorrect = false; OutDatedFiles.Add(BuildFile); } ProcessedBytes += BuildFileSize; CurrentBuildPercentage = ProcessedBytes / TotalBuildSizeDouble; } return bAllCorrect && !FBuildPatchInstallError::HasFatalError(); }
void FRawStaticIndexBuffer::GetCopy(TArray<uint32>& OutIndices) const { int32 NumIndices = b32Bit ? (IndexStorage.Num() / 4) : (IndexStorage.Num() / 2); OutIndices.Empty(NumIndices); OutIndices.AddUninitialized(NumIndices); if (b32Bit) { // If the indices are 32 bit we can just do a memcpy. check(IndexStorage.Num() == OutIndices.Num() * OutIndices.GetTypeSize()); FMemory::Memcpy(OutIndices.GetData(),IndexStorage.GetData(),IndexStorage.Num()); } else { // Copy element by element promoting 16-bit integers to 32-bit. check(IndexStorage.Num() == OutIndices.Num() * sizeof(uint16)); const uint16* SrcIndices16Bit = (const uint16*)IndexStorage.GetData(); for (int32 i = 0; i < NumIndices; ++i) { OutIndices[i] = SrcIndices16Bit[i]; } } }
// 全ソケットの情報を取得 void USsPlayerComponent::QuerySupportedSockets(TArray<FComponentSocketDescription>& OutSockets) const { OutSockets.Empty(); if( (RenderMode != ESsPlayerComponentRenderMode::OffScreenOnly) && (Player.GetSsProject().IsValid()) ) { int32 AnimPackIndex = Player.GetPlayingAnimPackIndex(); int32 AnimationIndex = Player.GetPlayingAnimationIndex(); if((0 <= AnimPackIndex) && (0 <= AnimationIndex)) { FSsAnimation& Animation = Player.GetSsProject()->AnimeList[AnimPackIndex].AnimeList[AnimationIndex]; for(int32 i = 0; i < Animation.PartAnimes.Num(); ++i) { OutSockets.Add( FComponentSocketDescription( Animation.PartAnimes[i].PartName, EComponentSocketType::Socket )); } } } }
void FAutoReimportManager::Destroy() { if (auto* AssetRegistryModule = FModuleManager::GetModulePtr<FAssetRegistryModule>("AssetRegistry")) { AssetRegistryModule->Get().OnAssetRenamed().RemoveAll(this); } if (auto* Settings = GetMutableDefault<UEditorLoadingSavingSettings>()) { Settings->OnSettingChanged().RemoveAll(this); } FPackageName::OnContentPathMounted().RemoveAll(this); FPackageName::OnContentPathDismounted().RemoveAll(this); if (FAssetRegistryModule* AssetRegistryModule = FModuleManager::GetModulePtr<FAssetRegistryModule>("AssetRegistry")) { AssetRegistryModule->Get().OnInMemoryAssetDeleted().RemoveAll(this); } // Force a save of all the caches DirectoryMonitors.Empty(); }
bool ConvertOverlapResults(int32 NumOverlaps, PxOverlapHit* POverlapResults, const PxFilterData& QueryFilter, TArray<FOverlapResult>& OutOverlaps) { OutOverlaps.Empty(); bool bBlockingFound = false; for(int32 i=0; i<NumOverlaps; i++) { FOverlapResult NewOverlap; ConvertQueryOverlap( POverlapResults[i].shape, POverlapResults[i].actor, NewOverlap, QueryFilter); if(NewOverlap.bBlockingHit) { bBlockingFound = true; } AddUniqueOverlap(OutOverlaps, NewOverlap); } return bBlockingFound; }