TArray<FPropertySoftPath> DiffUtils::GetVisiblePropertiesInOrderDeclared(const UObject* ForObj, const TArray<FName>& Scope /*= TArray<FName>()*/) { TArray<FPropertySoftPath> Ret; if (ForObj) { const UClass* Class = ForObj->GetClass(); TSet<FString> HiddenCategories = FEditorCategoryUtils::GetHiddenCategories(Class); for (TFieldIterator<UProperty> PropertyIt(Class); PropertyIt; ++PropertyIt) { FName CategoryName = FObjectEditorUtils::GetCategoryFName(*PropertyIt); if (!HiddenCategories.Contains(CategoryName.ToString())) { if (PropertyIt->PropertyFlags&CPF_Edit) { TArray<FName> NewPath(Scope); NewPath.Push(PropertyIt->GetFName()); if (const UObjectProperty* ObjectProperty = Cast<UObjectProperty>(*PropertyIt)) { const UObject* const* BaseObject = reinterpret_cast<const UObject* const*>( ObjectProperty->ContainerPtrToValuePtr<void>(ForObj) ); if (BaseObject && *BaseObject) { Ret.Append( GetVisiblePropertiesInOrderDeclared(*BaseObject, NewPath) ); } } else { Ret.Push(NewPath); } } } } } return Ret; }
bool ANavLinkProxy::GetNavigationLinksArray(TArray<FNavigationLink>& OutLink, TArray<FNavigationSegmentLink>& OutSegments) const { OutLink.Append(PointLinks); OutSegments.Append(SegmentLinks); return (PointLinks.Num() > 0) || (SegmentLinks.Num() > 0); }
bool FAssetDataGatherer::GetAndTrimSearchResults(TArray<FAssetData*>& OutAssetResults, TArray<FString>& OutPathResults, TArray<FPackageDependencyData>& OutDependencyResults, TArray<FString>& OutCookedPackageNamesWithoutAssetDataResults, TArray<double>& OutSearchTimes, int32& OutNumFilesToSearch, int32& OutNumPathsToSearch, bool& OutIsDiscoveringFiles) { FScopeLock CritSectionLock(&WorkerThreadCriticalSection); OutAssetResults.Append(MoveTemp(AssetResults)); AssetResults.Reset(); OutPathResults.Append(MoveTemp(DiscoveredPaths)); DiscoveredPaths.Reset(); OutDependencyResults.Append(MoveTemp(DependencyResults)); DependencyResults.Reset(); OutCookedPackageNamesWithoutAssetDataResults.Append(MoveTemp(CookedPackageNamesWithoutAssetDataResults)); CookedPackageNamesWithoutAssetDataResults.Reset(); OutSearchTimes.Append(MoveTemp(SearchTimes)); SearchTimes.Reset(); OutNumFilesToSearch = FilesToSearch.Num(); OutNumPathsToSearch = NumPathsToSearchAtLastSyncPoint; OutIsDiscoveringFiles = bIsDiscoveringFiles; return (SearchStartTime > 0 || bIsDiscoveringFiles); }
void FIOSTargetSettingsCustomization::CopySetupFilesIntoProject() { // First copy the plist, it must get copied FText ErrorMessage; if (!SourceControlHelpers::CopyFileUnderSourceControl(GameInfoPath, EngineInfoPath, LOCTEXT("InfoPlist", "Info.plist"), /*out*/ ErrorMessage)) { FNotificationInfo Info(ErrorMessage); Info.ExpireDuration = 3.0f; FSlateNotificationManager::Get().AddNotification(Info); } else { // Now try to copy all of the icons, etc... (these can be ignored if the file already exists) TArray<FPlatformIconInfo> Graphics; Graphics.Empty(IconNames.Num() + LaunchImageNames.Num()); Graphics.Append(IconNames); Graphics.Append(LaunchImageNames); for (const FPlatformIconInfo& Info : Graphics) { const FString EngineImagePath = EngineGraphicsPath / Info.IconPath; const FString ProjectImagePath = GameGraphicsPath / Info.IconPath; if (!FPaths::FileExists(ProjectImagePath)) { SourceControlHelpers::CopyFileUnderSourceControl(ProjectImagePath, EngineImagePath, Info.IconName, /*out*/ ErrorMessage); } } } SavedLayoutBuilder->ForceRefreshDetails(); }
// Sets default values AProcTriangle::AProcTriangle() { USphereComponent* SphereComponent = CreateDefaultSubobject<USphereComponent>(TEXT("RootComponent")); RootComponent = SphereComponent; UProceduralMeshComponent* mesh = CreateDefaultSubobject<UProceduralMeshComponent>(TEXT("GeneratedMesh")); // Set this actor to call Tick() every frame. You can turn this off to improve performance if you don't need it. TArray<FVector> p = equilateral_triangle(1,1000.0, FVector(0, 0, 0)); p.Append(triforce_of_triangle(1, 1000.0, FVector(0, 0, 0))); p.Append(triforce_of_triangle(1, 1000.0/2, FVector(0, 0, 0))); p.Append(triforce_of_triangle(1, 1000.0/4, FVector(0, 0, 0))); p.Append(triforce_of_triangle(1, 1000.0/8, FVector(0, 0, 0))); p.Append(triforce_of_triangle(1, 1000.0/16, FVector(0, 0, 0))); TArray<int32> triangles = all_triangles(3*5); // With default options //mesh->CreateMeshSection(1, vertices, Triangles, TArray<FVector>(), TArray<FVector2D>(), TArray<FColor>(), TArray<FProcMeshTangent>(), false); mesh->CreateMeshSection(1, p, triangles, TArray<FVector>(), TArray<FVector2D>(), TArray<FColor>(), TArray<FProcMeshTangent>(), false); mesh->AttachTo(RootComponent); }
bool FAssetDataDiscovery::GetAndTrimSearchResults(TArray<FString>& OutDiscoveredPaths, TArray<FDiscoveredPackageFile>& OutDiscoveredFiles, int32& OutNumPathsToSearch) { FScopeLock CritSectionLock(&WorkerThreadCriticalSection); OutDiscoveredPaths.Append(MoveTemp(DiscoveredPaths)); DiscoveredPaths.Reset(); if (PriorityDiscoveredFiles.Num() > 0) { // Use PriorityDiscoveredFiles as scratch space, then move it back out - this puts the priority files at the start of the final list PriorityDiscoveredFiles.Append(MoveTemp(OutDiscoveredFiles)); PriorityDiscoveredFiles.Append(MoveTemp(NonPriorityDiscoveredFiles)); OutDiscoveredFiles = MoveTemp(PriorityDiscoveredFiles); } else { OutDiscoveredFiles.Append(MoveTemp(NonPriorityDiscoveredFiles)); } PriorityDiscoveredFiles.Reset(); NonPriorityDiscoveredFiles.Reset(); OutNumPathsToSearch = DirectoriesToSearch.Num(); return bIsDiscoveringFiles; }
bool ANavLinkProxy::GetNavigationLinksArray(TArray<FNavigationLink>& OutLink, TArray<FNavigationSegmentLink>& OutSegments) const { OutLink.Append(PointLinks); OutSegments.Append(SegmentLinks); if (SmartLinkComp->IsNavigationRelevant()) { OutLink.Add(SmartLinkComp->GetLink()); } return (PointLinks.Num() > 0) || (SegmentLinks.Num() > 0) || SmartLinkComp->IsNavigationRelevant(); }
//------------------------------------------------------------------------------ static bool BlueprintActionMenuUtilsImpl::IsUnexposedMemberAction(FBlueprintActionFilter const& Filter, FBlueprintActionInfo& BlueprintAction) { bool bIsFliteredOut = false; if (UFunction const* Function = BlueprintAction.GetAssociatedFunction()) { TArray<FString> AllExposedCategories; for (TWeakObjectPtr<UObject> Binding : BlueprintAction.GetBindings()) { if (UProperty* Property = Cast<UProperty>(Binding.Get())) { FString const ExposedCategoryMetadata = Property->GetMetaData(FBlueprintMetadata::MD_ExposeFunctionCategories); if (ExposedCategoryMetadata.IsEmpty()) { continue; } TArray<FString> PropertyExposedCategories; ExposedCategoryMetadata.ParseIntoArray(PropertyExposedCategories, TEXT(","), true); AllExposedCategories.Append(PropertyExposedCategories); } } FString FunctionCategory = Function->GetMetaData(FBlueprintMetadata::MD_FunctionCategory); bIsFliteredOut = !AllExposedCategories.Contains(FunctionCategory); } return bIsFliteredOut; }
TArray<FString> UCardDeckModel::GetDeckAffinities() const { TArray<FString> Affinities; Affinities.Add(TEXT("Universal")); Affinities.Append(HeroModel->Affinities); return Affinities; }
//------------------------------------------------------------------------------ static bool BlueprintNativeCodeGenUtilsImpl::GenerateModuleSourceFiles(const FBlueprintNativeCodeGenPaths& TargetPaths) { FText FailureReason; TArray<FString> PchIncludes; PchIncludes.Add(EngineHeaderFile); PchIncludes.Add(TEXT("GeneratedCodeHelpers.h")); TArray<FString> FilesToIncludeInModuleHeader; GConfig->GetArray(TEXT("BlueprintNativizationSettings"), TEXT("FilesToIncludeInModuleHeader"), FilesToIncludeInModuleHeader, GEditorIni); PchIncludes.Append(FilesToIncludeInModuleHeader); bool bSuccess = GameProjectUtils::GeneratePluginModuleHeaderFile(TargetPaths.RuntimeModuleFile(FBlueprintNativeCodeGenPaths::HFile), PchIncludes, FailureReason); if (bSuccess) { const FString NoStartupCode = TEXT(""); bSuccess &= GameProjectUtils::GeneratePluginModuleCPPFile(TargetPaths.RuntimeModuleFile(FBlueprintNativeCodeGenPaths::CppFile), TargetPaths.RuntimeModuleName(), NoStartupCode, FailureReason); } if (!bSuccess) { UE_LOG(LogBlueprintCodeGen, Error, TEXT("Failed to generate module source files: %s"), *FailureReason.ToString()); } return bSuccess; }
void SVisualLogger::HandleSaveCommandExecute() { TArray<TSharedPtr<class STimeline> > OutTimelines; MainView->GetTimelines(OutTimelines, true); if (OutTimelines.Num() == 0) { MainView->GetTimelines(OutTimelines); } if (OutTimelines.Num()) { // Prompt the user for the filenames TArray<FString> SaveFilenames; IDesktopPlatform* DesktopPlatform = FDesktopPlatformModule::Get(); bool bSaved = false; if (DesktopPlatform) { void* ParentWindowWindowHandle = NULL; IMainFrameModule& MainFrameModule = FModuleManager::LoadModuleChecked<IMainFrameModule>(TEXT("MainFrame")); const TSharedPtr<SWindow>& MainFrameParentWindow = MainFrameModule.GetParentWindow(); if (MainFrameParentWindow.IsValid() && MainFrameParentWindow->GetNativeWindow().IsValid()) { ParentWindowWindowHandle = MainFrameParentWindow->GetNativeWindow()->GetOSWindowHandle(); } const FString DefaultBrowsePath = FString::Printf(TEXT("%slogs/"), *FPaths::GameSavedDir()); bSaved = DesktopPlatform->SaveFileDialog( ParentWindowWindowHandle, LOCTEXT("NewProjectBrowseTitle", "Choose a project location").ToString(), DefaultBrowsePath, TEXT(""), LogVisualizer::SaveFileTypes, EFileDialogFlags::None, SaveFilenames ); } if (bSaved) { if (SaveFilenames.Num() > 0) { TArray<FVisualLogDevice::FVisualLogEntryItem> FrameCache; for (auto CurrentItem : OutTimelines) { FrameCache.Append(CurrentItem->GetEntries()); } if (FrameCache.Num()) { FArchive* FileArchive = IFileManager::Get().CreateFileWriter(*SaveFilenames[0]); FVisualLoggerHelpers::Serialize(*FileArchive, FrameCache); FileArchive->Close(); delete FileArchive; FileArchive = NULL; } } } } }
bool FPerforceCopyWorker::Execute(class FPerforceSourceControlCommand& InCommand) { FScopedPerforceConnection ScopedConnection(InCommand); if (!InCommand.IsCanceled() && ScopedConnection.IsValid()) { FPerforceConnection& Connection = ScopedConnection.GetConnection(); check(InCommand.Operation->GetName() == GetName()); TSharedRef<FCopy, ESPMode::ThreadSafe> Operation = StaticCastSharedRef<FCopy>(InCommand.Operation); FString DestinationPath = FPaths::ConvertRelativePathToFull(Operation->GetDestination()); TArray<FString> Parameters; Parameters.Append(InCommand.Files); Parameters.Add(DestinationPath); FP4RecordSet Records; InCommand.bCommandSuccessful = Connection.RunCommand(TEXT("integrate"), Parameters, Records, InCommand.ErrorMessages, FOnIsCancelled::CreateRaw(&InCommand, &FPerforceSourceControlCommand::IsCanceled), InCommand.bConnectionDropped); // We now need to do a p4 resolve. // This is because when we copy a file in the Editor, we first make the copy on disk before attempting to branch. This causes a conflict in P4's eyes. // We must do this to prevent the asset registry from picking up what it thinks is a newly-added file (which would be created by the p4 integrate command) // and then the package system getting very confused about where to save the now-duplicated assets. if(InCommand.bCommandSuccessful) { TArray<FString> ResolveParameters; ResolveParameters.Add(TEXT("-ay")); // 'accept yours' ResolveParameters.Add(DestinationPath); InCommand.bCommandSuccessful = Connection.RunCommand(TEXT("resolve"), ResolveParameters, Records, InCommand.ErrorMessages, FOnIsCancelled::CreateRaw(&InCommand, &FPerforceSourceControlCommand::IsCanceled), InCommand.bConnectionDropped); } } return InCommand.bCommandSuccessful; }
bool FTCPTransport::SendPayloadAndReceiveResponse(TArray<uint8>& In, TArray<uint8>& Out) { bool SendResult = false; #if USE_MCSOCKET_FOR_NFS SendResult = FNFSMessageHeader::WrapAndSendPayload(In, FSimpleAbstractSocket_FMultichannelTCPSocket(MCSocket, NFS_Channels::Main)); #else SendResult = FNFSMessageHeader::WrapAndSendPayload(In, FSimpleAbstractSocket_FSocket(FileSocket)); #endif if (!SendResult) return false; FArrayReader Response; bool RetResult = false; #if USE_MCSOCKET_FOR_NFS RetResult = FNFSMessageHeader::ReceivePayload(Response, FSimpleAbstractSocket_FMultichannelTCPSocket(MCSocket, NFS_Channels::Main)); #else RetResult = FNFSMessageHeader::ReceivePayload(Response, FSimpleAbstractSocket_FSocket(FileSocket)); #endif if (RetResult) { Out.Append( Response.GetData(), Response.Num()); return true; } return false; }
bool FBuildPatchAppManifest::DeserializeFromData(const TArray<uint8>& DataInput) { if (DataInput.Num()) { if (BufferIsJsonManifest(DataInput)) { FString JsonManifest; FFileHelper::BufferToString(JsonManifest, DataInput.GetData(), DataInput.Num()); return DeserializeFromJSON(JsonManifest); } else { FMemoryReader ManifestFile(DataInput); FManifestFileHeader Header; ManifestFile << Header; const int32 SignedHeaderSize = Header.HeaderSize; if (Header.CheckMagic() && DataInput.Num() > SignedHeaderSize) { FSHAHashData DataHash; FSHA1::HashBuffer(&DataInput[Header.HeaderSize], DataInput.Num() - Header.HeaderSize, DataHash.Hash); if (DataHash == Header.SHAHash) { TArray<uint8> UncompressedData; if (Header.StoredAs == FChunkHeader::STORED_COMPRESSED && (Header.CompressedSize + Header.HeaderSize) == DataInput.Num()) { UncompressedData.AddUninitialized(Header.DataSize); if (!FCompression::UncompressMemory( static_cast<ECompressionFlags>(COMPRESS_ZLIB | COMPRESS_BiasMemory), UncompressedData.GetData(), Header.DataSize, &DataInput[Header.HeaderSize], DataInput.Num() - Header.HeaderSize)) { return false; } } else if ((Header.DataSize + Header.HeaderSize) == DataInput.Num()) { UncompressedData.Append(&DataInput[Header.HeaderSize], Header.DataSize); } else { return false; } FManifestReader ManifestData(UncompressedData); return Serialize(ManifestData); } else { return false; } } else { return false; } } } return false; }
TArray<int32> all_triangles(int n) { TArray<int32> triangles = triangle_helper(0); for (int i = 1; i < n; i++) { triangles.Append(triangle_helper(i)); } return triangles; }
static PyObject *py_ue_ihttp_request_set_content(ue_PyIHttpRequest *self, PyObject * args) { PyObject *py_obj; if (!PyArg_ParseTuple(args, "O:set_content", &py_obj)) { return NULL; } if (PyUnicode_Check(py_obj)) { self->http_request->SetContentAsString(UTF8_TO_TCHAR(PyUnicode_AsUTF8(py_obj))); } else if (PyBytes_Check(py_obj)) { char *buf = nullptr; Py_ssize_t len = 0; PyBytes_AsStringAndSize(py_obj, &buf, &len); TArray<uint8> data; data.Append((uint8 *)buf, len); self->http_request->SetContent(data); } Py_INCREF(Py_None); return Py_None; }
bool FProfilerClientManager::HandleTicker( float DeltaTime ) { #if STATS if (PendingInstances.Num() > 0 && FDateTime::Now() > LastPingTime + DeltaTime) { TArray<FGuid> Instances; Instances.Append(PendingInstances); PendingInstances.Reset(); for (int32 i = 0; i < Instances.Num(); ++i) { Track(Instances[i]); } LastPingTime = FDateTime::Now(); } else if (LoadConnection) { #if PROFILER_THREADED_LOAD return AsyncLoad(); #else return SyncLoad(); #endif } #endif return false; }
bool FPerforceSyncWorker::Execute(FPerforceSourceControlCommand& InCommand) { FScopedPerforceConnection ScopedConnection(InCommand); if (!InCommand.IsCanceled() && ScopedConnection.IsValid()) { FPerforceConnection& Connection = ScopedConnection.GetConnection(); TArray<FString> Parameters; Parameters.Append(InCommand.Files); // check for directories and add '...' for(auto& FileName : Parameters) { if(FileName.EndsWith(TEXT("/"))) { FileName += TEXT("..."); } } FP4RecordSet Records; InCommand.bCommandSuccessful = Connection.RunCommand(TEXT("sync"), Parameters, Records, InCommand.ErrorMessages, FOnIsCancelled::CreateRaw(&InCommand, &FPerforceSourceControlCommand::IsCanceled), InCommand.bConnectionDropped); ParseSyncResults(Records, OutResults); RemoveRedundantErrors(InCommand, TEXT("file(s) up-to-date")); } return InCommand.bCommandSuccessful; }
bool FPerforceMarkForAddWorker::Execute(FPerforceSourceControlCommand& InCommand) { // Perforce will allow you to mark files for add that don't currently exist on disk // This goes against the workflow of our other SCC providers (such as SVN and Git), // so we manually check that the files exist before allowing this command to continue // This keeps the behavior consistent between SCC providers bool bHasMissingFiles = false; for(const FString& FileToAdd : InCommand.Files) { if(!IFileManager::Get().FileExists(*FileToAdd)) { bHasMissingFiles = true; InCommand.ErrorMessages.Add(FText::Format(LOCTEXT("Error_FailedToMarkFileForAdd_FileMissing", "Failed mark the file '{0}' for add. The file doesn't exist on disk."), FText::FromString(FileToAdd))); } } if(bHasMissingFiles) { InCommand.bCommandSuccessful = false; return false; } FScopedPerforceConnection ScopedConnection(InCommand); if (!InCommand.IsCanceled() && ScopedConnection.IsValid()) { FPerforceConnection& Connection = ScopedConnection.GetConnection(); TArray<FString> Parameters; FP4RecordSet Records; Parameters.Append(InCommand.Files); InCommand.bCommandSuccessful = Connection.RunCommand(TEXT("add"), Parameters, Records, InCommand.ErrorMessages, FOnIsCancelled::CreateRaw(&InCommand, &FPerforceSourceControlCommand::IsCanceled), InCommand.bConnectionDropped); ParseRecordSetForState(Records, OutResults); } return InCommand.bCommandSuccessful; }
bool FPerforceCheckOutWorker::Execute(FPerforceSourceControlCommand& InCommand) { FScopedPerforceConnection ScopedConnection(InCommand); if (!InCommand.IsCanceled() && ScopedConnection.IsValid()) { FPerforceConnection& Connection = ScopedConnection.GetConnection(); TArray<FString> Parameters; FPerforceSourceControlModule& PerforceSourceControl = FModuleManager::LoadModuleChecked<FPerforceSourceControlModule>("PerforceSourceControl"); FPerforceSourceControlSettings& Settings = PerforceSourceControl.AccessSettings(); if (Settings.GetChangelistNumber().IsEmpty() == false) { Parameters.Add(TEXT("-c")); Parameters.Add(Settings.GetChangelistNumber()); // Parameters.Add(FString::Printf(TEXT("-c %s"), *Settings.GetChangelistNumber())); } Parameters.Append(InCommand.Files); FP4RecordSet Records; InCommand.bCommandSuccessful = Connection.RunCommand(TEXT("edit"), Parameters, Records, InCommand.ErrorMessages, FOnIsCancelled::CreateRaw(&InCommand, &FPerforceSourceControlCommand::IsCanceled), InCommand.bConnectionDropped); ParseRecordSetForState(Records, OutResults); } return InCommand.bCommandSuccessful; }
bool UMP3Decoder::Decode(TArray<uint8> &OutBuffer) { check(OutBuffer.Num() == 0); check(OutBuffer.GetAllocatedSize() >= WAV_HEADER_SIZE); OutBuffer.AddZeroed(WAV_HEADER_SIZE / OutBuffer.GetTypeSize()); FDateTime tStart = FDateTime::Now(); unsigned char* BlockBuffer = (unsigned char*)FMemory::Malloc(BlockBufferSize); size_t bytesRead = 0; size_t done = 0; int result; do { result = mpg123_read(Handle, BlockBuffer, BlockBufferSize, &done); bytesRead += done; OutBuffer.Append(BlockBuffer, done); } while (result == MPG123_OK); uint8 header[WAV_HEADER_SIZE]; WriteWaveHeader(header, bytesRead, Samplerate, Channels); FMemory::Memcpy(OutBuffer.GetData(), header, WAV_HEADER_SIZE); FMemory::Free(BlockBuffer); SizeInBytes = bytesRead; bool bSuccess = result == MPG123_OK || result == MPG123_DONE; UE_LOG(MP3ImporterLog, Display, TEXT("Decoding finished. %s bytes in %d ms. Success: %s"), *FString::FormatAsNumber((int32)bytesRead), (int32)(FDateTime::Now() - tStart).GetTotalMilliseconds(), bSuccess ? TEXT("True") : TEXT("False")); return bSuccess; }
// Have a similar process function for the normal tcp connection. void FNetworkFileServerHttp::Process(FArchive& In, TArray<uint8>&Out, FNetworkFileServerHttp* Server) { int loops = 0; while(!In.AtEnd()) { UE_LOG(LogFileServer, Log, TEXT("In %d "), loops++); // Every Request has a Guid attached to it - similar to Web session IDs. FGuid ClientGuid; In << ClientGuid; UE_LOG(LogFileServer, Log, TEXT("Recieved GUID %s"), *ClientGuid.ToString()); FNetworkFileServerClientConnectionHTTP* Connection = NULL; if (Server->RequestHandlers.Contains(ClientGuid)) { UE_LOG(LogFileServer, Log, TEXT("Picking up an existing handler" )); Connection = Server->RequestHandlers[ClientGuid]; } else { UE_LOG(LogFileServer, Log, TEXT("Creating a handler" )); Connection = Server->CreateNewConnection(); Server->RequestHandlers.Add(ClientGuid,Connection); } Connection->ProcessPayload(In); Out.Append(Connection->GetOutBuffer()); Connection->ResetBuffer(); } }
// TODO: exploit a better algorithm, use vertex hash table/map. // void mxRenderMesh::WeldVertices() { TArray< mxVertex > newVerts; newVerts.Resize( GetVertexCount() ); for ( u32 triIdx = 0; triIdx < GetTriangleCount(); triIdx++ ) { IndexTriple & rTri = Triangles[ triIdx ]; for ( TIndex i = 0; i < 3; i++ ) { const mxVertex & rCurrVertex = Vertices[ rTri[i] ]; s32 iExistingVertex = -1; for ( TIndex iVtx = 0; iVtx < newVerts.Num(); iVtx++ ) { if ( VectorsEqual( newVerts[ iVtx ].Pos, rCurrVertex.Pos ) ) { iExistingVertex = iVtx; break; } } if ( iExistingVertex != -1 ) { rTri[ i ] = iExistingVertex; } else { rTri[ i ] = newVerts.Append( mxVertex( rCurrVertex ) ); } } } Vertices = newVerts; }
virtual bool CookConvex(FName Format, const TArray<FVector>& SrcBuffer, TArray<uint8>& OutBuffer, bool bDeformableMesh = false) const override { #if WITH_PHYSX PxPlatform::Enum PhysXFormat = PxPlatform::ePC; bool bIsPhysXFormatValid = GetPhysXFormat(Format, PhysXFormat); check(bIsPhysXFormatValid); PxConvexMeshDesc PConvexMeshDesc; PConvexMeshDesc.points.data = SrcBuffer.GetData(); PConvexMeshDesc.points.count = SrcBuffer.Num(); PConvexMeshDesc.points.stride = sizeof(FVector); if (bDeformableMesh) { PConvexMeshDesc.flags = PxConvexFlag::eCOMPUTE_CONVEX | PxConvexFlag::eINFLATE_CONVEX; } else { PConvexMeshDesc.flags = PxConvexFlag::eCOMPUTE_CONVEX; } // Set up cooking const PxCookingParams Params = PhysXCooking->getParams(); PxCookingParams NewParams = Params; NewParams.targetPlatform = PhysXFormat; if (bDeformableMesh) { // Meshes which can be deformed need different cooking parameters to inhibit vertex welding and add an extra skin around the collision mesh for safety. // We need to set the meshWeldTolerance to zero, even when disabling 'clean mesh' as PhysX will attempt to perform mesh cleaning anyway according to this meshWeldTolerance // if the convex hull is not well formed. // Set the skin thickness as a proportion of the overall size of the mesh as PhysX's internal tolerances also use the overall size to calculate the epsilon used. const FBox Bounds(SrcBuffer); const float MaxExtent = (Bounds.Max - Bounds.Min).Size(); NewParams.skinWidth = MaxExtent / 512.0f; NewParams.meshPreprocessParams = PxMeshPreprocessingFlags(PxMeshPreprocessingFlag::eDISABLE_CLEAN_MESH); NewParams.areaTestEpsilon = 0.0f; NewParams.meshWeldTolerance = 0.0f; PhysXCooking->setParams(NewParams); } // Cook the convex mesh to a temp buffer TArray<uint8> CookedMeshBuffer; FPhysXOutputStream Buffer(&CookedMeshBuffer); bool Result = PhysXCooking->cookConvexMesh(PConvexMeshDesc, Buffer); // Return default cooking params to normal if (bDeformableMesh) { PhysXCooking->setParams(Params); } if( Result && CookedMeshBuffer.Num() > 0 ) { // Append the cooked data into cooked buffer OutBuffer.Append( CookedMeshBuffer ); return true; } #endif // WITH_PHYSX return false; }
bool FWebSocket::Send(uint8* Data, uint32 Size) { TArray<uint8> Buffer; #if !PLATFORM_HTML5 Buffer.AddDefaulted(LWS_PRE); // Reserve space for WS header data #endif Buffer.Append((uint8*)&Size, sizeof (uint32)); // insert size. Buffer.Append((uint8*)Data, Size); CriticalSection.Lock(); OutgoingBuffer.Add(Buffer); OutgoingBufferType.Add( LWS_WRITE_BINARY ); CriticalSection.Unlock(); return true; }
void SGameplayTagWidget::VerifyAssetTagValidity() { FGameplayTagContainer LibraryTags; // Create a set that is the library of all valid tags TArray< TSharedPtr<FGameplayTagNode> > NodeStack; UGameplayTagsManager& TagsManager = IGameplayTagsModule::Get().GetGameplayTagsManager(); TagsManager.GetFilteredGameplayRootTags(TEXT(""), NodeStack); while (NodeStack.Num() > 0) { TSharedPtr<FGameplayTagNode> CurNode = NodeStack.Pop(); if (CurNode.IsValid()) { LibraryTags.AddTag(TagsManager.RequestGameplayTag(CurNode->GetCompleteTag())); NodeStack.Append(CurNode->GetChildTagNodes()); } } // Find and remove any tags on the asset that are no longer in the library for (int32 ContainerIdx = 0; ContainerIdx < TagContainers.Num(); ++ContainerIdx) { UObject* OwnerObj = TagContainers[ContainerIdx].TagContainerOwner.Get(); FGameplayTagContainer* Container = TagContainers[ContainerIdx].TagContainer; if (Container) { FGameplayTagContainer EditableContainer = *Container; FGameplayTagContainer InvalidTags; for (auto It = Container->CreateConstIterator(); It; ++It) { if (!LibraryTags.HasTag(*It, EGameplayTagMatchType::Explicit, EGameplayTagMatchType::Explicit)) { InvalidTags.AddTag(*It); } } if (InvalidTags.Num() > 0) { FString InvalidTagNames; for (auto InvalidIter = InvalidTags.CreateConstIterator(); InvalidIter; ++InvalidIter) { EditableContainer.RemoveTag(*InvalidIter); InvalidTagNames += InvalidIter->ToString() + TEXT("\n"); } SetContainer(Container, &EditableContainer, OwnerObj); FFormatNamedArguments Arguments; Arguments.Add(TEXT("Objects"), FText::FromString( InvalidTagNames )); FText DialogText = FText::Format( LOCTEXT("GameplayTagWidget_InvalidTags", "Invalid Tags that have been removed: \n\n{Objects}"), Arguments ); OpenMsgDlgInt( EAppMsgType::Ok, DialogText, LOCTEXT("GameplayTagWidget_Warning", "Warning") ); } } } }
//------------------------------------------------------------------------------ static bool BlueprintNativeCodeGenUtilsImpl::GenerateModuleBuildFile(const FBlueprintNativeCodeGenManifest& Manifest) { FModuleManager& ModuleManager = FModuleManager::Get(); TArray<FString> PublicDependencies; // for IModuleInterface PublicDependencies.Add(CoreModuleName); // for Engine.h PublicDependencies.Add(EngineModuleName); if (GameProjectUtils::ProjectHasCodeFiles()) { const FString GameModuleName = FApp::GetGameName(); if (ModuleManager.ModuleExists(*GameModuleName)) { PublicDependencies.Add(GameModuleName); } } TArray<FString> AdditionalPublicDependencyModuleNames; GConfig->GetArray(TEXT("BlueprintNativizationSettings"), TEXT("AdditionalPublicDependencyModuleNames"), AdditionalPublicDependencyModuleNames, GEditorIni); PublicDependencies.Append(AdditionalPublicDependencyModuleNames); TArray<FString> PrivateDependencies; const TArray<UPackage*>& ModulePackages = Manifest.GetModuleDependencies(); PrivateDependencies.Reserve(ModulePackages.Num()); for (UPackage* ModulePkg : ModulePackages) { const FString PkgModuleName = FPackageName::GetLongPackageAssetName(ModulePkg->GetName()); if (ModuleManager.ModuleExists(*PkgModuleName)) { if (!PublicDependencies.Contains(PkgModuleName)) { PrivateDependencies.Add(PkgModuleName); } } else { UE_LOG(LogBlueprintCodeGen, Warning, TEXT("Failed to find module for package: %s"), *PkgModuleName); } } FBlueprintNativeCodeGenPaths TargetPaths = Manifest.GetTargetPaths(); FText ErrorMessage; bool bSuccess = GameProjectUtils::GenerateGameModuleBuildFile(TargetPaths.RuntimeBuildFile(), TargetPaths.RuntimeModuleName(), PublicDependencies, PrivateDependencies, ErrorMessage); if (!bSuccess) { UE_LOG(LogBlueprintCodeGen, Error, TEXT("Failed to generate module build file: %s"), *ErrorMessage.ToString()); } return bSuccess; }
void ABot::executeNextAction(){ TArray<Action*> possibleActions; for (TActorIterator<AUnit> unitItr(GetWorld()); unitItr; ++unitItr){ if (unitItr->GetUniqueID() != this->GetUniqueID()) possibleActions.Append(unitItr->getExposedActions()); } worldModel.setActions(possibleActions); Action* nextAction = planner->planAction(worldModel, 2); nextAction->executeAction(this); }
void FAssetTypeActions_DataTable::OpenAssetEditor( const TArray<UObject*>& InObjects, TSharedPtr<IToolkitHost> EditWithinLevelEditor ) { TArray<UDataTable*> DataTablesToOpen; TArray<UDataTable*> InvalidDataTables; for (UObject* Obj : InObjects) { UDataTable* Table = Cast<UDataTable>(Obj); if (Table) { if (Table->RowStruct) { DataTablesToOpen.Add(Table); } else { InvalidDataTables.Add(Table); } } } if (InvalidDataTables.Num() > 0) { FTextBuilder DataTablesListText; DataTablesListText.Indent(); for (UDataTable* Table : InvalidDataTables) { const FName ResolvedRowStructName = Table->GetRowStructName(); DataTablesListText.AppendLineFormat(LOCTEXT("DataTable_MissingRowStructListEntry", "* {0} (Row Structure: {1})"), FText::FromString(Table->GetName()), FText::FromName(ResolvedRowStructName)); } const EAppReturnType::Type DlgResult = OpenMsgDlgInt( EAppMsgType::YesNoCancel, FText::Format(LOCTEXT("DataTable_MissingRowStructMsg", "The following Data Tables are missing their row structure and will not be editable.\n\n{0}\n\nDo you want to open these data tables?"), DataTablesListText.ToText()), LOCTEXT("DataTable_MissingRowStructTitle", "Continue?") ); switch(DlgResult) { case EAppReturnType::Yes: DataTablesToOpen.Append(InvalidDataTables); break; case EAppReturnType::Cancel: return; default: break; } } FDataTableEditorModule& DataTableEditorModule = FModuleManager::LoadModuleChecked<FDataTableEditorModule>("DataTableEditor"); for (UDataTable* Table : DataTablesToOpen) { DataTableEditorModule.CreateDataTableEditor(EToolkitMode::Standalone, EditWithinLevelEditor, Table); } }
bool FWebSocket::Send(uint8* Data, uint32 Size) { TArray<uint8> Buffer; // insert size. #if !PLATFORM_HTML5 Buffer.Append((uint8*)&PREPADDING, sizeof(PREPADDING)); #endif Buffer.Append((uint8*)&Size, sizeof (uint32)); Buffer.Append((uint8*)Data, Size); #if !PLATFORM_HTML5 Buffer.Append((uint8*)&POSTPADDING, sizeof(POSTPADDING)); #endif OutgoingBuffer.Add(Buffer); return true; }