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