void FEditorModeTools::JumpToBookmark( uint32 InIndex, bool bShouldRestoreLevelVisibility, FEditorViewportClient* InViewportClient ) { UWorld* World = InViewportClient->GetWorld(); if ( World ) { AWorldSettings* WorldSettings = World->GetWorldSettings(); // Can only jump to a pre-existing bookmark if ( WorldSettings && InIndex < AWorldSettings::MAX_BOOKMARK_NUMBER && WorldSettings->BookMarks[ InIndex ] ) { const UBookMark* CurBookMark = WorldSettings->BookMarks[ InIndex ]; check(CurBookMark); // Set all level editing cameras to this bookmark for( int32 v = 0 ; v < GEditor->LevelViewportClients.Num() ; v++ ) { GEditor->LevelViewportClients[v]->SetViewLocation( CurBookMark->Location ); if( !GEditor->LevelViewportClients[v]->IsOrtho() ) { GEditor->LevelViewportClients[v]->SetViewRotation( CurBookMark->Rotation ); } GEditor->LevelViewportClients[v]->Invalidate(); } } } }
void FPhATEdPreviewViewportClient::Tick(float DeltaSeconds) { FEditorViewportClient::Tick(DeltaSeconds); UWorld* World = SharedData->PreviewScene.GetWorld(); if (SharedData->bRunningSimulation) { // check if PIE disabled the realtime viewport and quit sim if so if (!bIsRealtime) { SharedData->ToggleSimulation(); Invalidate(); } AWorldSettings* Setting = World->GetWorldSettings(); Setting->WorldGravityZ = SharedData->bNoGravitySimulation ? 0.0f : UPhysicsSettings::Get()->DefaultGravityZ*SharedData->EditorSimOptions->GravScale; Setting->bWorldGravitySet = true; // We back up the transforms array now SharedData->EditorSkelComp->AnimationSpaceBases = SharedData->EditorSkelComp->GetComponentSpaceTransforms(); SharedData->EditorSkelComp->SetPhysicsBlendWeight(SharedData->EditorSimOptions->PhysicsBlend); SharedData->EditorSkelComp->bUpdateJointsFromAnimation = SharedData->EditorSimOptions->bUpdateJointsFromAnimation; SharedData->EditorSkelComp->PhysicsTransformUpdateMode = SharedData->EditorSimOptions->PhysicsUpdateMode; static FPhysicalAnimationData EmptyProfile; SharedData->PhysicalAnimationComponent->ApplyPhysicalAnimationProfileBelow(NAME_None, SharedData->PhysicsAsset->CurrentPhysicalAnimationProfileName, /*Include Self=*/true, /*Clear Not Found=*/true); } World->Tick(LEVELTICK_All, DeltaSeconds * SharedData->EditorSimOptions->TimeDilation); }
void UWorldComposition::UpdateStreamingState() { UWorld* PlayWorld = GetWorld(); check(PlayWorld); // Commandlets and Dedicated server does not use distance based streaming and just loads everything if (IsRunningCommandlet() || PlayWorld->GetNetMode() == NM_DedicatedServer) { UpdateStreamingState(FVector::ZeroVector); return; } int32 NumPlayers = GEngine->GetNumGamePlayers(PlayWorld); if (NumPlayers == 0) { return; } // calculate centroid location using local players views bool bCinematic = false; FVector CentroidLocation = FVector::ZeroVector; TArray<FVector, TInlineAllocator<16>> Locations; for (int32 PlayerIndex = 0; PlayerIndex < NumPlayers; ++PlayerIndex) { ULocalPlayer* Player = GEngine->GetGamePlayer(PlayWorld, PlayerIndex); if (Player && Player->PlayerController) { FVector ViewLocation; FRotator ViewRotation; Player->PlayerController->GetPlayerViewPoint(ViewLocation, ViewRotation); Locations.Add(ViewLocation); CentroidLocation+= ViewLocation; bCinematic|= Player->PlayerController->bCinematicMode; } } // In case there is no valid views don't bother updating level streaming state if (Locations.Num()) { CentroidLocation/= Locations.Num(); if (PlayWorld->GetWorldSettings()->bEnableWorldOriginRebasing) { EvaluateWorldOriginLocation(CentroidLocation); } if (bCinematic) { UpdateStreamingStateCinematic(Locations.GetData(), Locations.Num()); } else { UpdateStreamingState(Locations.GetData(), Locations.Num()); } } }
bool FEditorModeTools::CheckBookmark( uint32 InIndex, FEditorViewportClient* InViewportClient ) { UWorld* World = InViewportClient->GetWorld(); if ( World ) { AWorldSettings* WorldSettings = World->GetWorldSettings(); if ( WorldSettings && InIndex < AWorldSettings::MAX_BOOKMARK_NUMBER && WorldSettings->BookMarks[ InIndex ] ) { return ( WorldSettings->BookMarks[ InIndex ] ? true : false ); } } return false; }
/** * Clears a bookmark */ void FEditorModeTools::ClearBookmark( uint32 InIndex, FEditorViewportClient* InViewportClient ) { UWorld* World = InViewportClient->GetWorld(); if( World ) { AWorldSettings* pWorldSettings = World->GetWorldSettings(); // Verify the index is valid for the bookmark if ( pWorldSettings && InIndex < AWorldSettings::MAX_BOOKMARK_NUMBER ) { pWorldSettings->BookMarks[ InIndex ] = NULL; } } }
float UAirBlueprintLib::GetWorldToMetersScale(const AActor* context) { float w2m = 100.f; UWorld* w = context->GetWorld(); if (w != nullptr) { AWorldSettings* ws = w->GetWorldSettings(); if (ws != nullptr) { w2m = ws->WorldToMeters; } } return w2m; }
void UOSVRInputComponent::InitializeComponent() { Super::InitializeComponent(); WorldToMetersScale = 100.f; UWorld* w = GetWorld(); if (w != nullptr) { AWorldSettings* ws = w->GetWorldSettings(); if (ws != nullptr) { WorldToMetersScale = ws->WorldToMeters; } } auto InterfaceCollection = IOSVR::Get().GetEntryPoint()->GetInterfaceCollection(); OSVRInterfaceCollection::RegistrationToken RegToken = InterfaceCollection->RegisterOnStateChangedCallback( [=](OSVRInterface* Interface, uint32 State) { /* FTransform Pose; if (((State & OSVRInterface::POSE_STATE_AVAILABLE) > 0) && Interface->GetPose(Pose, false)) { Pose.ScaleTranslation(WorldToMetersScale); OnPoseChanged.Broadcast(Interface->GetName(), Pose); } */ FVector Position; if (((State & OSVRInterface::POSITION_STATE_AVAILABLE) > 0) && Interface->GetPosition(Position, false)) OnPositionChanged.Broadcast(Interface->GetName(), Position * WorldToMetersScale); FQuat Orientation; if (((State & OSVRInterface::ORIENTATION_STATE_AVAILABLE) > 0) && Interface->GetOrientation(Orientation, false)) OnOrientationChanged.Broadcast(Interface->GetName(), Orientation.Rotator()); float Analog; if (((State & OSVRInterface::ANALOG_STATE_AVAILABLE) > 0) && Interface->GetAnalogState(Analog, false)) OnAnalogValueChanged.Broadcast(Interface->GetName(), Analog); uint8 Button; if (((State & OSVRInterface::BUTTON_STATE_AVAILABLE) > 0) && Interface->GetButtonState(Button, false)) OnButtonStateChanged.Broadcast(Interface->GetName(), EButtonState::Type(Button)); }); RegistrationToken = RegToken.Token; }
void FHierarchicalLODOutlinerModule::OnHLODLevelsArrayChangedEvent() { UWorld* CurrentWorld = nullptr; // Get the correct UWorld instance for (const FWorldContext& Context : GEngine->GetWorldContexts()) { if (Context.WorldType == EWorldType::PIE) { CurrentWorld = Context.World(); break; } else if (Context.WorldType == EWorldType::Editor) { CurrentWorld = Context.World(); } } AWorldSettings* WorldSettings = (CurrentWorld) ? CurrentWorld->GetWorldSettings() : nullptr; if (WorldSettings) { TArray<FHierarchicalSimplification>& HierarchicalLODSetup = WorldSettings->HierarchicalLODSetup; int32 NumHLODLevels = WorldSettings->NumHLODLevels; if (HierarchicalLODSetup.Num() > 1 && HierarchicalLODSetup.Num() > NumHLODLevels) { // HLOD level was added, use previous level settings to "guess" new settings FHierarchicalSimplification& NewLevelSetup = HierarchicalLODSetup.Last(); const FHierarchicalSimplification& OldLastLevelSetup = HierarchicalLODSetup[HierarchicalLODSetup.Num() - 2]; NewLevelSetup.bSimplifyMesh = OldLastLevelSetup.bSimplifyMesh; NewLevelSetup.MergeSetting = OldLastLevelSetup.MergeSetting; NewLevelSetup.ProxySetting = OldLastLevelSetup.ProxySetting; NewLevelSetup.DesiredBoundRadius = OldLastLevelSetup.DesiredBoundRadius * 2.5f; NewLevelSetup.DesiredFillingPercentage = FMath::Max(OldLastLevelSetup.DesiredFillingPercentage * 0.75f, 1.0f); NewLevelSetup.TransitionScreenSize = OldLastLevelSetup.TransitionScreenSize * 0.75f; NewLevelSetup.MinNumberOfActorsToBuild = OldLastLevelSetup.MinNumberOfActorsToBuild; } else if (HierarchicalLODSetup.Num() < NumHLODLevels) { // HLOD Level was removed, now remove all LODActors for this level FHierarchicalLODUtilities::DeleteLODActorsInHLODLevel(CurrentWorld, NumHLODLevels - 1); } } }
void FEditorModeTools::SetBookmark( uint32 InIndex, FEditorViewportClient* InViewportClient ) { UWorld* World = InViewportClient->GetWorld(); if ( World ) { AWorldSettings* WorldSettings = World->GetWorldSettings(); // Verify the index is valid for the bookmark if ( WorldSettings && InIndex < AWorldSettings::MAX_BOOKMARK_NUMBER ) { // If the index doesn't already have a bookmark in place, create a new one if ( !WorldSettings->BookMarks[ InIndex ] ) { WorldSettings->BookMarks[ InIndex ] = ConstructObject<UBookMark>( UBookMark::StaticClass(), WorldSettings ); } UBookMark* CurBookMark = WorldSettings->BookMarks[ InIndex ]; check(CurBookMark); check(InViewportClient); // Use the rotation from the first perspective viewport can find. FRotator Rotation(0,0,0); if( !InViewportClient->IsOrtho() ) { Rotation = InViewportClient->GetViewRotation(); } CurBookMark->Location = InViewportClient->GetViewLocation(); CurBookMark->Rotation = Rotation; // Keep a record of which levels were hidden so that we can restore these with the bookmark CurBookMark->HiddenLevels.Empty(); for ( int32 LevelIndex = 0 ; LevelIndex < World->StreamingLevels.Num() ; ++LevelIndex ) { ULevelStreaming* StreamingLevel = World->StreamingLevels[LevelIndex]; if ( StreamingLevel ) { if( !StreamingLevel->bShouldBeVisibleInEditor ) { CurBookMark->HiddenLevels.Add( StreamingLevel->GetFullName() ); } } } } } }
AActor* AGameModeBase::FindPlayerStart_Implementation(AController* Player, const FString& IncomingName) { UWorld* World = GetWorld(); // If incoming start is specified, then just use it if (!IncomingName.IsEmpty()) { const FName IncomingPlayerStartTag = FName(*IncomingName); for (TActorIterator<APlayerStart> It(World); It; ++It) { APlayerStart* Start = *It; if (Start && Start->PlayerStartTag == IncomingPlayerStartTag) { return Start; } } } // Always pick StartSpot at start of match if (ShouldSpawnAtStartSpot(Player)) { if (AActor* PlayerStartSpot = Player->StartSpot.Get()) { return PlayerStartSpot; } else { UE_LOG(LogGameMode, Error, TEXT("Error - ShouldSpawnAtStartSpot returned true but the Player StartSpot was null.")); } } AActor* BestStart = ChoosePlayerStart(Player); if (BestStart == nullptr) { // No player start found UE_LOG(LogGameMode, Log, TEXT("Warning - PATHS NOT DEFINED or NO PLAYERSTART with positive rating")); // This is a bit odd, but there was a complex chunk of code that in the end always resulted in this, so we may as well just // short cut it down to this. Basically we are saying spawn at 0,0,0 if we didn't find a proper player start BestStart = World->GetWorldSettings(); } return BestStart; }
void AKillZVolume::ActorEnteredVolume(AActor* Other) { Super::ActorEnteredVolume(Other); if ( Other ) { const UDamageType* DamageType = GetDefault<UDamageType>(); UWorld* World = GetWorld(); if ( World ) { AWorldSettings* WorldSettings = World->GetWorldSettings( true ); if ( WorldSettings && WorldSettings->KillZDamageType ) { DamageType = WorldSettings->KillZDamageType->GetDefaultObject<UDamageType>(); } } Other->FellOutOfWorld(*DamageType); } }
void AWorldSettings::CheckForErrors() { Super::CheckForErrors(); UWorld* World = GetWorld(); if ( World->GetWorldSettings() != this ) { FMessageLog("MapCheck").Warning() ->AddToken(FUObjectToken::Create(this)) ->AddToken(FTextToken::Create(LOCTEXT( "MapCheck_Message_DuplicateLevelInfo", "Duplicate level info" ) )) ->AddToken(FMapErrorToken::Create(FMapErrors::DuplicateLevelInfo)); } if( World->NumLightingUnbuiltObjects > 0 ) { FMessageLog("MapCheck").Error() ->AddToken(FUObjectToken::Create(this)) ->AddToken(FTextToken::Create(LOCTEXT( "MapCheck_Message_RebuildLighting", "Maps need lighting rebuilt" ) )) ->AddToken(FMapErrorToken::Create(FMapErrors::RebuildLighting)); } }
UWorld* NUTNet::CreateUnitTestWorld(bool bHookTick/*=true*/) { UWorld* ReturnVal = NULL; // Unfortunately, this hack is needed, to avoid a crash when running as commandlet // NOTE: Sometimes, depending upon build settings, PRIVATE_GIsRunningCommandlet is a define instead of a global #ifndef PRIVATE_GIsRunningCommandlet bool bIsCommandlet = PRIVATE_GIsRunningCommandlet; PRIVATE_GIsRunningCommandlet = false; #endif ReturnVal = UWorld::CreateWorld(EWorldType::None, false); #ifndef PRIVATE_GIsRunningCommandlet PRIVATE_GIsRunningCommandlet = bIsCommandlet; #endif if (ReturnVal != NULL) { UnitTestWorlds.Add(ReturnVal); // Hook the new worlds 'tick' event, so that we can capture logging if (bHookTick) { FWorldTickHook* TickHook = new FWorldTickHook(ReturnVal); ActiveTickHooks.Add(TickHook); TickHook->Init(); } // Hack-mark the world as having begun play (when it has not) ReturnVal->bBegunPlay = true; // Hack-mark the world as having initialized actors (to allow RPC hooks) ReturnVal->bActorsInitialized = true; // Enable pause, using the PlayerController of the primary world (unless we're in the editor) if (!GIsEditor) { AWorldSettings* CurSettings = ReturnVal->GetWorldSettings(); if (CurSettings != NULL) { ULocalPlayer* PrimLocPlayer = GEngine->GetFirstGamePlayer(NUTUtil::GetPrimaryWorld()); APlayerController* PrimPC = (PrimLocPlayer != NULL ? PrimLocPlayer->PlayerController : NULL); APlayerState* PrimState = (PrimPC != NULL ? PrimPC->PlayerState : NULL); if (PrimState != NULL) { CurSettings->Pauser = PrimState; } } } // Create a blank world context, to prevent crashes FWorldContext& CurContext = GEngine->CreateNewWorldContext(EWorldType::None); CurContext.SetCurrentWorld(ReturnVal); } return ReturnVal; }
void AGameModeBase::ReplicateStreamingStatus(APlayerController* PC) { UWorld* MyWorld = GetWorld(); if (MyWorld->GetWorldSettings()->bUseClientSideLevelStreamingVolumes) { // Client will itself decide what to stream return; } // Don't do this for local players or players after the first on a splitscreen client if (Cast<ULocalPlayer>(PC->Player) == nullptr && Cast<UChildConnection>(PC->Player) == nullptr) { // If we've loaded levels via CommitMapChange() that aren't normally in the StreamingLevels array, tell the client about that if (MyWorld->CommittedPersistentLevelName != NAME_None) { PC->ClientPrepareMapChange(MyWorld->CommittedPersistentLevelName, true, true); // Tell the client to commit the level immediately PC->ClientCommitMapChange(); } if (MyWorld->StreamingLevels.Num() > 0) { // Tell the player controller the current streaming level status for (int32 LevelIndex = 0; LevelIndex < MyWorld->StreamingLevels.Num(); LevelIndex++) { ULevelStreaming* TheLevel = MyWorld->StreamingLevels[LevelIndex]; if (TheLevel != nullptr) { const ULevel* LoadedLevel = TheLevel->GetLoadedLevel(); UE_LOG(LogGameMode, Log, TEXT("levelStatus: %s %i %i %i %s %i"), *TheLevel->GetWorldAssetPackageName(), TheLevel->bShouldBeVisible, LoadedLevel && LoadedLevel->bIsVisible, TheLevel->bShouldBeLoaded, *GetNameSafe(LoadedLevel), TheLevel->bHasLoadRequestPending); PC->ClientUpdateLevelStreamingStatus( TheLevel->GetWorldAssetPackageFName(), TheLevel->bShouldBeLoaded, TheLevel->bShouldBeVisible, TheLevel->bShouldBlockOnLoad, TheLevel->LevelLODIndex); } } PC->ClientFlushLevelStreaming(); } // If we're preparing to load different levels using PrepareMapChange() inform the client about that now if (MyWorld->PreparingLevelNames.Num() > 0) { for (int32 LevelIndex = 0; LevelIndex < MyWorld->PreparingLevelNames.Num(); LevelIndex++) { PC->ClientPrepareMapChange(MyWorld->PreparingLevelNames[LevelIndex], LevelIndex == 0, LevelIndex == MyWorld->PreparingLevelNames.Num() - 1); } // DO NOT commit these changes yet - we'll send that when we're done preparing them } } }