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