bool SVisualLoggerFilters::IsAssetTypeActionsInUse(FName InGraphName, FName InDataName) const
{
if (GraphFilters.Contains(InGraphName))
{
for (const FString& Filter : GraphFilters[InGraphName])
{
if (Filter == InDataName.ToString())
{
const FString GraphFilterName = InGraphName.ToString() + TEXT("$") + Filter;
return FCategoryFiltersManager::Get().GetCategory(GraphFilterName).Enabled;
}
}
}
return false;
}
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;
}
FName FActorFolders::GetDefaultFolderName(UWorld& InWorld, FName ParentPath)
{
// This is potentially very slow but necessary to find a unique name
const auto& ExistingFolders = GetFolderPropertiesForWorld(InWorld);
// Create a valid base name for this folder
uint32 Suffix = 1;
FText LeafName = FText::Format(LOCTEXT("DefaultFolderNamePattern", "NewFolder{0}"), FText::AsNumber(Suffix++));
FString ParentFolderPath = ParentPath.IsNone() ? TEXT("") : ParentPath.ToString();
if (!ParentFolderPath.IsEmpty())
{
ParentFolderPath += "/";
}
FName FolderName(*(ParentFolderPath + LeafName.ToString()));
while (ExistingFolders.Contains(FolderName))
{
LeafName = FText::Format(LOCTEXT("DefaultFolderNamePattern", "NewFolder{0}"), FText::AsNumber(Suffix++));
FolderName = FName(*(ParentFolderPath + LeafName.ToString()));
if (Suffix == 0)
{
// We've wrapped around a 32bit unsigned int - something must be seriously wrong!
return FName();
}
}
return FolderName;
}
FName UTimelineTemplate::GetTrackPropertyName(const FName TrackName) const
{
const FString TimelineName = TimelineTemplateNameToVariableName(GetFName());
FString PropertyName = FString::Printf(TEXT("%s_%s_%s"), *TimelineName, *TrackName.ToString(), *TimelineGuid.ToString());
SanitizePropertyName(PropertyName);
return FName(*PropertyName);
}
ULevelStreaming* SetStreamingClassForLevel(ULevelStreaming* InLevel, UClass* LevelStreamingClass)
{
check(InLevel);
const FScopedBusyCursor BusyCursor;
// Cache off the package name, as it will be lost when unloading the level
const FName CachedPackageName = InLevel->PackageName;
// First hide and remove the level if it exists
ULevel* Level = InLevel->GetLoadedLevel();
check(Level);
SetLevelVisibility( Level, false, false );
check(Level->OwningWorld);
UWorld* World = Level->OwningWorld;
World->StreamingLevels.Remove(InLevel);
// re-add the level with the desired streaming class
AddLevelToWorld(World, *(CachedPackageName.ToString()), LevelStreamingClass);
// Set original level transform
ULevelStreaming* NewStreamingLevel = FLevelUtils::FindStreamingLevel( Level );
if ( NewStreamingLevel )
{
NewStreamingLevel->LevelTransform = InLevel->LevelTransform;
}
return NewStreamingLevel;
}
FArchive& operator<<(FArchive& Ar,FShaderType*& Ref)
{
if(Ar.IsSaving())
{
FName ShaderTypeName = Ref ? FName(Ref->Name) : NAME_None;
Ar << ShaderTypeName;
}
else if(Ar.IsLoading())
{
FName ShaderTypeName = NAME_None;
Ar << ShaderTypeName;
Ref = NULL;
if(ShaderTypeName != NAME_None)
{
// look for the shader type in the global name to type map
FShaderType** ShaderType = FShaderType::GetNameToTypeMap().Find(ShaderTypeName);
if (ShaderType)
{
// if we found it, use it
Ref = *ShaderType;
}
else
{
UE_LOG(LogShaders, Warning, TEXT("ShaderType '%s' was not found!"), *ShaderTypeName.ToString());
}
}
}
return Ar;
}
const TSharedPtr< FSlateDynamicImageBrush > FSlateStyleSet::GetDynamicImageBrush(const FName BrushTemplate, UTexture2D* TextureResource, const FName TextureName)
{
//create a resource name
FName ResourceName;
ResourceName = TextureName == NAME_None ? BrushTemplate : FName(*( BrushTemplate.ToString() + TextureName.ToString() ));
//see if we already have that brush
TWeakPtr< FSlateDynamicImageBrush > WeakImageBrush = DynamicBrushes.FindRef(ResourceName);
//if we don't have the image brush, then make it
TSharedPtr< FSlateDynamicImageBrush > ReturnBrush = WeakImageBrush.Pin();
if ( !ReturnBrush.IsValid() )
{
const FSlateBrush* Result = BrushResources.FindRef(Join(BrushTemplate, nullptr));
if ( Result == nullptr )
{
Result = GetDefaultBrush();
}
//create the new brush
ReturnBrush = MakeShareable(new FSlateDynamicImageBrush(TextureResource, Result->ImageSize, ResourceName));
//add it to the dynamic brush list
DynamicBrushes.Add(ResourceName, ReturnBrush);
}
return ReturnBrush;
}
/**
* Computes the derived data key suffix for a SoundWave's Streamed Audio.
* @param SoundWave - The SoundWave for which to compute the derived data key.
* @param AudioFormatName - The audio format we're creating the key for
* @param OutKeySuffix - The derived data key suffix.
*/
static void GetStreamedAudioDerivedDataKeySuffix(
const USoundWave& SoundWave,
FName AudioFormatName,
FString& OutKeySuffix
)
{
uint16 Version = 0;
// get the version for this soundwave's platform format
ITargetPlatformManagerModule* TPM = GetTargetPlatformManager();
if (TPM)
{
const IAudioFormat* AudioFormat = TPM->FindAudioFormat(AudioFormatName);
if (AudioFormat)
{
Version = AudioFormat->GetVersion(AudioFormatName);
}
}
// build the key
OutKeySuffix = FString::Printf(TEXT("%s_%d_%s"),
*AudioFormatName.ToString(),
Version,
*SoundWave.CompressedDataGuid.ToString()
);
}
void DumpSessionSettings(const FOnlineSessionSettings* SessionSettings)
{
if (SessionSettings != NULL)
{
UE_LOG(LogOnline, Verbose, TEXT("dumping SessionSettings: "));
UE_LOG(LogOnline, Verbose, TEXT("\tNumPublicConnections: %d"), SessionSettings->NumPublicConnections);
UE_LOG(LogOnline, Verbose, TEXT("\tNumPrivateConnections: %d"), SessionSettings->NumPrivateConnections);
UE_LOG(LogOnline, Verbose, TEXT("\tbIsLanMatch: %s"), SessionSettings->bIsLANMatch ? TEXT("true") : TEXT("false"));
UE_LOG(LogOnline, Verbose, TEXT("\tbIsDedicated: %s"), SessionSettings->bIsDedicated ? TEXT("true") : TEXT("false"));
UE_LOG(LogOnline, Verbose, TEXT("\tbUsesStats: %s"), SessionSettings->bUsesStats ? TEXT("true") : TEXT("false"));
UE_LOG(LogOnline, Verbose, TEXT("\tbShouldAdvertise: %s"), SessionSettings->bShouldAdvertise ? TEXT("true") : TEXT("false"));
UE_LOG(LogOnline, Verbose, TEXT("\tbAllowJoinInProgress: %s"), SessionSettings->bAllowJoinInProgress ? TEXT("true") : TEXT("false"));
UE_LOG(LogOnline, Verbose, TEXT("\tbAllowInvites: %s"), SessionSettings->bAllowInvites ? TEXT("true") : TEXT("false"));
UE_LOG(LogOnline, Verbose, TEXT("\tbUsesPresence: %s"), SessionSettings->bUsesPresence ? TEXT("true") : TEXT("false"));
UE_LOG(LogOnline, Verbose, TEXT("\tbAllowJoinViaPresence: %s"), SessionSettings->bAllowJoinViaPresence ? TEXT("true") : TEXT("false"));
UE_LOG(LogOnline, Verbose, TEXT("\tbAllowJoinViaPresenceFriendsOnly: %s"), SessionSettings->bAllowJoinViaPresenceFriendsOnly ? TEXT("true") : TEXT("false"));
UE_LOG(LogOnline, Verbose, TEXT("\tBuildUniqueId: 0x%08x"), SessionSettings->BuildUniqueId);
UE_LOG(LogOnline, Verbose, TEXT("\tSettings:"));
for (FSessionSettings::TConstIterator It(SessionSettings->Settings); It; ++It)
{
FName Key = It.Key();
const FOnlineSessionSetting& Setting = It.Value();
UE_LOG(LogOnline, Verbose, TEXT("\t\t%s=%s"), *Key.ToString(), *Setting.ToString());
}
}
}
//
// Require an identifier.
//
void FBaseParser::RequireIdentifier( FName Match, const TCHAR* Tag )
{
if (!MatchIdentifier(Match))
{
FError::Throwf(TEXT("Missing '%s' in %s"), *Match.ToString(), Tag );
}
}
void UVisualLoggerKismetLibrary::LogText(UObject* WorldContextObject, FString Text, FName CategoryName)
{
#if ENABLE_VISUAL_LOG
const ELogVerbosity::Type DefaultVerbosity = ELogVerbosity::Log;
FVisualLogger::CategorizedLogf(WorldContextObject, FLogCategoryBase(*CategoryName.ToString(), DefaultVerbosity, DefaultVerbosity), DefaultVerbosity, INDEX_NONE, *Text);
#endif
}
/**
* Main entry point for accessing an online subsystem by name
* Will load the appropriate module if the subsystem isn't currently loaded
* It's possible that the subsystem doesn't exist and therefore can return NULL
*
* @param SubsystemName - name of subsystem as referenced by consumers
* @return Requested online subsystem, or NULL if that subsystem was unable to load or doesn't exist
*/
IOnlineSubsystem* FOnlineSubsystemModule::GetOnlineSubsystem(const FName InSubsystemName)
{
FName SubsystemName = InSubsystemName;
if (SubsystemName == NAME_None)
{
SubsystemName = DefaultPlatformService;
}
IOnlineSubsystem** OSSFactory = NULL;
if (SubsystemName != NAME_None)
{
OSSFactory = PlatformServices.Find(SubsystemName);
if (OSSFactory == NULL)
{
// Attempt to load the requested factory
TSharedPtr<IModuleInterface> NewModule = LoadSubsystemModule(SubsystemName.ToString());
if( NewModule.IsValid() )
{
// If the module loaded successfully this should be non-NULL;
OSSFactory = PlatformServices.Find(SubsystemName);
}
if (OSSFactory == NULL)
{
UE_LOG(LogOnline, Warning, TEXT("Unable to load OnlineSubsystem module %s"), *InSubsystemName.ToString());
}
}
}
return (OSSFactory == NULL) ? NULL : *OSSFactory;
}
bool FStructureEditorUtils::AddVariable(UBlueprint* Blueprint, FName StructName, const FEdGraphPinType& VarType)
{
if (NULL != Blueprint)
{
const FScopedTransaction Transaction( LOCTEXT("AddVariable", "Add Variable") );
Blueprint->Modify();
FBPStructureDescription* StructureDesc = Blueprint->UserDefinedStructures.FindByPredicate(FFindByNameHelper(StructName));
if (StructureDesc)
{
FString ErrorMessage;
if (!CanHaveAMemberVariableOfType(StructureDesc->CompiledStruct, VarType, &ErrorMessage))
{
UE_LOG(LogBlueprint, Warning, TEXT("%s"), *ErrorMessage);
return false;
}
const FName VarName = FMemberVariableNameHelper::Generate(StructureDesc->CompiledStruct, FString());
check(NULL == StructureDesc->Fields.FindByPredicate(FFindByNameHelper(VarName)));
const FString DisplayName = VarName.ToString();
check(IsUniqueVariableDisplayName(Blueprint, StructName, DisplayName));
FBPVariableDescription NewVar;
NewVar.VarName = VarName;
NewVar.FriendlyName = DisplayName;
NewVar.VarType = VarType;
NewVar.VarGuid = FGuid::NewGuid();
StructureDesc->Fields.Add(NewVar);
OnStructureChanged(*StructureDesc, Blueprint);
return true;
}
}
return false;
}
bool FDataTableExporterJSON::WriteTable()
{
if (!DataTable->RowStruct)
{
return false;
}
JsonWriter->WriteArrayStart();
// Iterate over rows
for (auto RowIt = DataTable->RowMap.CreateConstIterator(); RowIt; ++RowIt)
{
JsonWriter->WriteObjectStart();
{
// RowName
const FName RowName = RowIt.Key();
JsonWriter->WriteValue(TEXT("Name"), RowName.ToString());
// Now the values
uint8* RowData = RowIt.Value();
WriteRow(RowData);
}
JsonWriter->WriteObjectEnd();
}
JsonWriter->WriteArrayEnd();
return true;
}
void FSlateRHIResourceManager::CreateTextures( const TArray< const FSlateBrush* >& Resources )
{
DECLARE_SCOPE_CYCLE_COUNTER(TEXT("Loading Slate Textures"), STAT_Slate, STATGROUP_LoadTime);
TMap<FName,FNewTextureInfo> TextureInfoMap;
const uint32 Stride = GPixelFormats[PF_R8G8B8A8].BlockBytes;
for( int32 ResourceIndex = 0; ResourceIndex < Resources.Num(); ++ResourceIndex )
{
const FSlateBrush& Brush = *Resources[ResourceIndex];
const FName TextureName = Brush.GetResourceName();
if( TextureName != NAME_None && !Brush.HasUObject() && !Brush.IsDynamicallyLoaded() && !ResourceMap.Contains(TextureName) )
{
// Find the texture or add it if it doesnt exist (only load the texture once)
FNewTextureInfo& Info = TextureInfoMap.FindOrAdd( TextureName );
Info.bSrgb = (Brush.ImageType != ESlateBrushImageType::Linear);
// Only atlas the texture if none of the brushes that use it tile it and the image is srgb
Info.bShouldAtlas &= ( Brush.Tiling == ESlateBrushTileType::NoTile && Info.bSrgb && AtlasSize > 0 );
// Texture has been loaded if the texture data is valid
if( !Info.TextureData.IsValid() )
{
uint32 Width = 0;
uint32 Height = 0;
TArray<uint8> RawData;
bool bSucceeded = LoadTexture( Brush, Width, Height, RawData );
Info.TextureData = MakeShareable( new FSlateTextureData( Width, Height, Stride, RawData ) );
const bool bTooLargeForAtlas = (Width >= 256 || Height >= 256 || Width >= AtlasSize || Height >= AtlasSize );
Info.bShouldAtlas &= !bTooLargeForAtlas;
if( !bSucceeded || !ensureMsgf( Info.TextureData->GetRawBytes().Num() > 0, TEXT("Slate resource: (%s) contains no data"), *TextureName.ToString() ) )
{
TextureInfoMap.Remove( TextureName );
}
}
}
}
// Sort textures by size. The largest textures are atlased first which creates a more compact atlas
TextureInfoMap.ValueSort( FCompareFNewTextureInfoByTextureSize() );
for( TMap<FName,FNewTextureInfo>::TConstIterator It(TextureInfoMap); It; ++It )
{
const FNewTextureInfo& Info = It.Value();
FName TextureName = It.Key();
FString NameStr = TextureName.ToString();
checkSlow( TextureName != NAME_None );
FSlateShaderResourceProxy* NewTexture = GenerateTextureResource( Info );
ResourceMap.Add( TextureName, NewTexture );
}
}
TArray< TArray<FString> > UDataTable::GetTableData() const
{
TArray< TArray<FString> > Result;
Result.Add(GetColumnTitles());
// First build array of properties
TArray<UProperty*> StructProps;
for (TFieldIterator<UProperty> It(RowStruct); It; ++It)
{
UProperty* Prop = *It;
check(Prop != NULL);
StructProps.Add(Prop);
}
// Now iterate over rows
for ( auto RowIt = RowMap.CreateConstIterator(); RowIt; ++RowIt )
{
TArray<FString> RowResult;
FName RowName = RowIt.Key();
RowResult.Add(RowName.ToString());
uint8* RowData = RowIt.Value();
for(int32 PropIdx=0; PropIdx<StructProps.Num(); PropIdx++)
{
RowResult.Add(DataTableUtils::GetPropertyValueAsString(StructProps[PropIdx], RowData));
}
Result.Add(RowResult);
}
return Result;
}
bool UJavascriptContext::InternalCall(UObject* Object, FName Name)
{
auto context = JavascriptContext->context();
auto func = JavascriptContext->GetProxyFunction(Object, *(Name.ToString()));
if (!func.IsEmpty() && func->IsFunction())
{
auto function = Local<Function>::Cast(func);
TryCatch try_catch;
fastcall::call(context->Global(), function);
if (try_catch.HasCaught())
{
FV8Exception::Report(try_catch);
return false;
}
else
{
return true;
}
}
else
{
return false;
}
}
void AFlareGame::Immatriculate(UFlareCompany* Company, FName TargetClass, FFlareSpacecraftSave* SpacecraftSave)
{
FString Immatriculation;
FString NickName;
CurrentImmatriculationIndex++;
FFlareSpacecraftDescription* SpacecraftDesc = SpacecraftCatalog->Get(TargetClass);
bool IsStation = FFlareSpacecraftDescription::IsStation(SpacecraftDesc);
// Company name
Immatriculation += Company->GetShortName().ToString().ToUpper();
// Class
Immatriculation += SpacecraftDesc->ImmatriculationCode.ToString().ToUpper();
// Name
if (SpacecraftDesc->Size == EFlarePartSize::L && !IsStation)
{
NickName = PickCapitalShipName().ToString();
}
else
{
NickName = FString::Printf(TEXT("%04d"), CurrentImmatriculationIndex);
}
Immatriculation += FString::Printf(TEXT("-%s"), *NickName);
// Update data
FLOGV("AFlareGame::Immatriculate (%s) : %s", *TargetClass.ToString(), *Immatriculation);
SpacecraftSave->Immatriculation = FName(*Immatriculation);
SpacecraftSave->NickName = FText::FromString(NickName);
}
UK2Node::ERedirectType UK2Node_MakeStruct::DoPinsMatchForReconstruction(const UEdGraphPin* NewPin, int32 NewPinIndex, const UEdGraphPin* OldPin, int32 OldPinIndex) const
{
ERedirectType Result = UK2Node::DoPinsMatchForReconstruction(NewPin, NewPinIndex, OldPin, OldPinIndex);
if ((ERedirectType_None == Result) && DoRenamedPinsMatch(NewPin, OldPin, false))
{
Result = ERedirectType_Custom;
}
else if ((ERedirectType_None == Result) && NewPin && OldPin)
{
const UEdGraphSchema_K2* K2Schema = GetDefault<UEdGraphSchema_K2>();
if ((EGPD_Output == NewPin->Direction) && (EGPD_Output == OldPin->Direction))
{
const UEdGraphSchema_K2* K2Schema = GetDefault<UEdGraphSchema_K2>();
if (K2Schema->ArePinTypesCompatible(NewPin->PinType, OldPin->PinType))
{
Result = ERedirectType_Custom;
}
}
else if ((EGPD_Input == NewPin->Direction) && (EGPD_Input == OldPin->Direction))
{
TMap<FName, FName>* StructRedirects = UStruct::TaggedPropertyRedirects.Find(StructType->GetFName());
if (StructRedirects)
{
FName* PropertyRedirect = StructRedirects->Find(FName(*OldPin->PinName));
if (PropertyRedirect)
{
Result = ((FCString::Stricmp(*PropertyRedirect->ToString(), *NewPin->PinName) != 0) ? ERedirectType_None : ERedirectType_Name);
}
}
}
}
return Result;
}
FString FLinker::GetExportFullName(int32 ExportIndex, const TCHAR* FakeRoot,bool bResolveForcedExports/*=false*/)
{
FPackageIndex ClassIndex = ExportMap[ExportIndex].ClassIndex;
FName ClassName = ClassIndex.IsNull() ? FName(NAME_Class) : ImpExp(ClassIndex).ObjectName;
return ClassName.ToString() + TEXT(" ") + GetExportPathName(ExportIndex, FakeRoot, bResolveForcedExports);
}
bool FOnlineSessionMakeshift::StartSession(FName SessionName)
{
uint32 Result = E_FAIL;
// Grab the session information by name
FNamedOnlineSession* Session = GetNamedSession(SessionName);
if (Session)
{
// Can't start a match multiple times
if (Session->SessionState == EOnlineSessionState::Pending ||
Session->SessionState == EOnlineSessionState::Ended)
{
// If this lan match has join in progress disabled, shut down the beacon
Result = UpdateLANStatus();
Session->SessionState = EOnlineSessionState::InProgress;
}
else
{
UE_LOG_ONLINE(Warning, TEXT("Can't start an online session (%s) in state %s"),
*SessionName.ToString(),
EOnlineSessionState::ToString(Session->SessionState));
}
}
else
{
UE_LOG_ONLINE(Warning, TEXT("Can't start an online game for session (%s) that hasn't been created"), *SessionName.ToString());
}
if (Result != ERROR_IO_PENDING)
{
// Just trigger the delegate
TriggerOnStartSessionCompleteDelegates(SessionName, (Result == ERROR_SUCCESS) ? true : false);
}
return Result == ERROR_SUCCESS || Result == ERROR_IO_PENDING;
}
FName MoveFolderTo(FName InPath, FName NewParent, UWorld& World)
{
FName NewPath = GetFolderLeafName(InPath);
if (!NewParent.IsNone())
{
NewPath = FName(*(NewParent.ToString() / NewPath.ToString()));
}
if (FActorFolders::Get().RenameFolderInWorld(World, InPath, NewPath))
{
return NewPath;
}
return FName();
}
FText UK2Node_VariableGet::GetPropertyTooltip(UProperty const* VariableProperty)
{
FName VarName = NAME_None;
if (VariableProperty != nullptr)
{
VarName = VariableProperty->GetFName();
UClass* SourceClass = VariableProperty->GetOwnerClass();
// discover if the variable property is a non blueprint user variable
bool const bIsNativeVariable = (SourceClass != nullptr) && (SourceClass->ClassGeneratedBy == nullptr);
FName const TooltipMetaKey(TEXT("tooltip"));
FText SubTooltip;
if (bIsNativeVariable)
{
FText const PropertyTooltip = VariableProperty->GetToolTipText();
if (!PropertyTooltip.IsEmpty())
{
// See if the native property has a tooltip
SubTooltip = PropertyTooltip;
FString TooltipName = FString::Printf(TEXT("%s.%s"), *VarName.ToString(), *TooltipMetaKey.ToString());
FText::FindText(*VariableProperty->GetFullGroupName(true), *TooltipName, SubTooltip);
}
}
else if (SourceClass)
{
if (UBlueprint* VarBlueprint = Cast<UBlueprint>(SourceClass->ClassGeneratedBy))
{
FString UserTooltipData;
if (FBlueprintEditorUtils::GetBlueprintVariableMetaData(VarBlueprint, VarName, /*InLocalVarScope =*/nullptr, TooltipMetaKey, UserTooltipData))
{
SubTooltip = FText::FromString(UserTooltipData);
}
}
}
if (!SubTooltip.IsEmpty())
{
FFormatNamedArguments Args;
Args.Add(TEXT("VarName"), FText::FromName(VarName));
Args.Add(TEXT("PropertyTooltip"), SubTooltip);
return FText::Format(LOCTEXT("GetVariableProperty_Tooltip", "Read the value of variable {VarName}\n{PropertyTooltip}"), Args);
}
}
return K2Node_VariableGetImpl::GetBaseTooltip(VarName);
}
void UpdateSceneCaptureContent_RenderThread(FSceneRenderer* SceneRenderer, FTextureRenderTargetResource* TextureRenderTarget, const FName OwnerName, const FResolveParams& ResolveParams, bool bUseSceneColorTexture)
{
FMemMark MemStackMark(FMemStack::Get());
// update any resources that needed a deferred update
FDeferredUpdateResource::UpdateResources();
{
#if WANTS_DRAW_MESH_EVENTS
FString EventName;
OwnerName.ToString(EventName);
SCOPED_DRAW_EVENTF(SceneCapture, DEC_SCENE_ITEMS, TEXT("SceneCapture %s"), *EventName);
#endif
// Render the scene normally
const FRenderTarget* Target = SceneRenderer->ViewFamily.RenderTarget;
FIntRect ViewRect = SceneRenderer->Views[0].ViewRect;
FIntRect UnconstrainedViewRect = SceneRenderer->Views[0].UnconstrainedViewRect;
RHISetRenderTarget(Target->GetRenderTargetTexture(), NULL);
RHIClear(true, FLinearColor::Black, false, 1.0f, false, 0, ViewRect);
SceneRenderer->Render();
// Copy the captured scene into the destination texture
if (bUseSceneColorTexture)
{
// Copy the captured scene into the destination texture
RHISetRenderTarget(Target->GetRenderTargetTexture(), NULL);
RHISetRasterizerState(TStaticRasterizerState<FM_Solid, CM_None>::GetRHI());
RHISetDepthStencilState(TStaticDepthStencilState<false, CF_Always>::GetRHI());
RHISetBlendState(TStaticBlendState<>::GetRHI());
TShaderMapRef<FScreenVS> VertexShader(GetGlobalShaderMap());
TShaderMapRef<FScreenPS> PixelShader(GetGlobalShaderMap());
static FGlobalBoundShaderState BoundShaderState;
SetGlobalBoundShaderState(BoundShaderState, GFilterVertexDeclaration.VertexDeclarationRHI, *VertexShader, *PixelShader);
FRenderingCompositePassContext Context(SceneRenderer->Views[0]);
VertexShader->SetParameters(SceneRenderer->Views[0]);
PixelShader->SetParameters(TStaticSamplerState<SF_Point>::GetRHI(), GSceneRenderTargets.GetSceneColorTexture());
FIntPoint TargetSize(UnconstrainedViewRect.Width(), UnconstrainedViewRect.Height());
DrawRectangle(
ViewRect.Min.X, ViewRect.Min.Y,
ViewRect.Width(), ViewRect.Height(),
ViewRect.Min.X, ViewRect.Min.Y,
ViewRect.Width(), ViewRect.Height(),
TargetSize,
GSceneRenderTargets.GetBufferSizeXY(),
EDRF_UseTriangleOptimization);
}
RHICopyToResolveTarget(TextureRenderTarget->GetRenderTargetTexture(), TextureRenderTarget->TextureRHI, false, ResolveParams);
}
delete SceneRenderer;
}
TSharedPtr<FSlateRHIResourceManager::FDynamicTextureResource> FSlateRHIResourceManager::MakeDynamicTextureResource(bool bHasUTexture, bool bIsDynamicallyLoaded, FString ResourcePath, FName ResourceName, UTexture2D* InTextureObject)
{
// Bail out if we already have this texture loaded
TSharedPtr<FDynamicTextureResource> TextureResource = DynamicTextureMap.FindRef( ResourceName );
if( TextureResource.IsValid() )
{
return TextureResource;
}
// Texture object if any
UTexture2D* TextureObject = NULL;
// Data for a loaded disk image
FNewTextureInfo Info;
bool bSucceeded = false;
if( bHasUTexture || InTextureObject != NULL )
{
if( InTextureObject )
{
TextureObject = InTextureObject;
}
else
{
// Load the utexture
FString Path = ResourceName.ToString();
Path = Path.RightChop( FSlateBrush::UTextureIdentifier().Len() );
TextureObject = LoadObject<UTexture2D>( NULL, *Path, NULL, LOAD_None, NULL );
}
bSucceeded = TextureObject != NULL;
}
else if( bIsDynamicallyLoaded )
{
uint32 Width = 0;
uint32 Height = 0;
TArray<uint8> RawData;
// Load the image from disk
bSucceeded = LoadTexture( ResourceName, ResourcePath, Width, Height, RawData );
Info.TextureData = MakeShareable( new FSlateTextureData( Width, Height, GPixelFormats[PF_B8G8R8A8].BlockBytes, RawData ) );
}
if( bSucceeded )
{
TextureResource = InitializeDynamicTextureResource( Info.TextureData, TextureObject );
// Map the new resource for the UTexture so we don't have to load again
DynamicTextureMap.Add( ResourceName, TextureResource );
}
else
{
// Add the null texture so we don't continuously try to load it.
DynamicTextureMap.Add( ResourceName, FDynamicTextureResource::NullResource );
}
return TextureResource;
}
void UAkGameplayStatics::SetRTPCValue( FName RTPC, float Value, int32 InterpolationTimeMs = 0, class AActor* Actor = NULL )
{
FAkAudioDevice * AudioDevice = FAkAudioDevice::Get();
if( AudioDevice && RTPC.IsValid() )
{
AudioDevice->SetRTPCValue( *RTPC.ToString(), Value, InterpolationTimeMs, Actor );
}
}
/** Creates a string key for the derived data cache entry for the global shader map. */
FString GetGlobalShaderMapKeyString(const FGlobalShaderMapId& ShaderMapId, EShaderPlatform Platform)
{
FName Format = LegacyShaderPlatformToShaderFormat(Platform);
FString ShaderMapKeyString = Format.ToString() + TEXT("_") + FString(FString::FromInt(GetTargetPlatformManagerRef().ShaderFormatVersion(Format))) + TEXT("_");
ShaderMapAppendKeyString(Platform, ShaderMapKeyString);
ShaderMapId.AppendKeyString(ShaderMapKeyString);
return FDerivedDataCacheInterface::BuildCacheKey(TEXT("GSM"), GLOBALSHADERMAP_DERIVEDDATA_VER, *ShaderMapKeyString);
}
void FBlackboardKeySelector::AddObjectFilter(UObject* Owner, FName PropertyName, TSubclassOf<UObject> AllowedClass)
{
static int32 FilterCounter = 0;
const FString FilterName = FString::Printf(TEXT("%s_Object_%d"), *PropertyName.ToString(), ++FilterCounter);
UBlackboardKeyType_Object* FilterOb = NewObject<UBlackboardKeyType_Object>(Owner, *FilterName);
FilterOb->BaseClass = AllowedClass;
AllowedTypes.Add(FilterOb);
}
FString FBlackboardSelectorDetails::GetCurrentKeyDesc() const
{
FName NameValue;
MyKeyNameProperty->GetValue(NameValue);
const int32 KeyIdx = KeyValues.IndexOfByKey(NameValue);
return KeyValues.IsValidIndex(KeyIdx) ? KeyValues[KeyIdx].ToString() : NameValue.ToString();
}
void UNameProperty::ExportTextItem( FString& ValueStr, const void* PropertyValue, const void* DefaultValue, UObject* Parent, int32 PortFlags, UObject* ExportRootScope ) const
{
FName Temp = *(FName*)PropertyValue;
if (0 != (PortFlags & PPF_ExportCpp))
{
ValueStr += (Temp == NAME_None)
? TEXT("FName()")
: FString::Printf(TEXT("FName(TEXT(\"%s\"))"), *(Temp.ToString().ReplaceCharWithEscapedChar()));
}
else if( !(PortFlags & PPF_Delimited) )
{
ValueStr += Temp.ToString();
}
else if ( Temp != NAME_None )
{
ValueStr += FString::Printf( TEXT("\"%s\""), *Temp.ToString() );
}
}
