izzy/UnrealEngineUWP
0
0
Fork 0
mirror of https://github.com/izzy2lost/UnrealEngineUWP.git synced 2026-03-26 18:15:20 -07:00
Code Issues Packages Projects Releases Wiki Activity
Files
37a47c18d0f610aadfcc0ef3fbe2ed17e0386f43
UnrealEngineUWP/Engine/Source/Runtime/Launch/Private/LaunchEngineLoop.cpp
Matt Kuhlenschmidt 37a47c18d0 Copying //UE4/Dev-Editor to //UE4/Dev-Main (Source: //UE4/Dev-Editor @ 3228984) 
#lockdown Nick.Penwarden
#rb none
==========================
MAJOR FEATURES + CHANGES
==========================

Change 3168749 on 2016/10/20 by Richard.TalbotWatkin

	Fixed bug in csgRebuild where dynamic brushes from the whole world are rebuilt instead of just those from the current level. csgRebuild is supposed to act only on the current level's geometry.
	#jira UE-37376 - csgRebuild builds dynamic brushes from the whole world, instead of just the current level

Change 3169740 on 2016/10/20 by Nick.Darnell

	Automation - Removing old screenshots, working on new naming convention.

Change 3169796 on 2016/10/20 by Nick.Darnell

	Automation - Adding new screenshots.

Change 3169800 on 2016/10/20 by Nick.Darnell

	Automation - Working on improvements to screenshot comparions, now using the Unique device id instead of adapter name.  Working on better metadata based matching for which screenshot to use, stubbing in support for adding alternative versions of screenshots.

Change 3169901 on 2016/10/20 by Nick.Darnell

	Automation - More fixes / refinements to the way we add alternatives and replace old versions of screenshots.

Change 3169926 on 2016/10/20 by Cody.Albert

	Added extension point for level editor viewport's Show and Camera menus

Change 3170053 on 2016/10/20 by Cody.Albert

	Back out changelist 3169926

Change 3170067 on 2016/10/20 by Cody.Albert

	Added extension point for level editor viewport's Show and Camera menus

Change 3170382 on 2016/10/21 by Michael.Dupuis

	#jira UE-36585 Added Copy/Paste to Material list/item, section list/item to StaticMeshEditor and Persona Editor

Change 3170520 on 2016/10/21 by Alex.Delesky

	#jira UE-36510 - You can now toggle if combo boxes can receive keyboard focus from the Widget Blueprint

Change 3170522 on 2016/10/21 by Alex.Delesky

	#jira UE-33031 - Buttons will no longer remained in a hovered state on mobile devices if the user drags their finger into a button, and then lifts their finger without dragging it outside of the button.

Change 3170524 on 2016/10/21 by Alex.Delesky

	#jira UE-25591 - Static Mesh LODs can now be removed from the editor without a mesh reduction tool like Simplygon configured for use in the editor.

Change 3170530 on 2016/10/21 by Alex.Delesky

	Moved the HasKey method from UMapProperty to FScriptMapHelper, and moved the HasElement property from USetProperty to FScriptSetHelper

	#jira none

Change 3170768 on 2016/10/21 by Cody.Albert

	Back out changelist 3170067

Change 3170795 on 2016/10/21 by Nick.Darnell

	JsonObjectConverter - By default UStructToJsonAttributes now skips transient properties.

Change 3170797 on 2016/10/21 by Nick.Darnell

	Automation - Fixing several warnings dealing with fbx testing.

Change 3170921 on 2016/10/21 by Nick.Darnell

	Automation - Fixing more warnings with FBX tests.

Change 3171109 on 2016/10/21 by Cody.Albert

	Added extension point for level editor viewport Show menu

Change 3171812 on 2016/10/24 by Jamie.Dale

	Back out changelist 3163044

	This broke wrapping for Japanese and Chinese.

Change 3171842 on 2016/10/24 by Michael.Dupuis

	#jira UE-36400
	Name each Parameter uniquely either from copy/paste of any creation menu
	Changed the default value for Scalar and Vector Parameter to 1 and 1,1,1,1
	Added a Promote To Parameter when clicking on an Input pin that will generate proper node type based on type pin type
	When editing a color property update the material expression preview

Change 3171958 on 2016/10/24 by Alex.Delesky

	#jira UE-37444 - The Primitive Stats browser (and other statistics browsers) can now sort columns based on singular objects or object types as well as texture dimensions.

Change 3171969 on 2016/10/24 by Nick.Darnell

	Slate - Adding some code to prevent crashes if bogus user indexes are passed into SlateApplications GetUser functions.

Change 3171970 on 2016/10/24 by Matt.Kuhlenschmidt

	PR #2885: Fixed Stretched Landscape Editor Icons (Contributed by teessider)

Change 3172035 on 2016/10/24 by Alex.Delesky

	Fix to build warning for 3171970

	#jira none

Change 3172078 on 2016/10/24 by Michael.Dupuis

	#jira UE-37626 Fetch property node from property handle if there is no property editor

Change 3172143 on 2016/10/24 by Jamie.Dale

	Line-break iterators will now avoid breaking words in Hangul

	The default behavior for wrapping Hangul is to use Western-style wrapping (where words are kept as-is) rather than East Asian-style (where words are broken by syllables). This behavior can be controlled by the Localization.HangulTextWrappingMethod CVar in-case you were dependant on the old behavior, but since modern Hangul uses spaces, the per-word wrapping is preferred by native speakers.

Change 3172418 on 2016/10/24 by Michael.Dupuis

	Fixed Static Analysis error

Change 3173389 on 2016/10/25 by Michael.Dupuis

	#jira UE-9284 Make the UI appear only on hover and change icons size

Change 3173918 on 2016/10/25 by Alex.Delesky

	#jira UE-37753 - WidgetBlueprints saved without a root widget (e.g., by deleting the starting Canvas panel) will no longer set a Canvas panel as the root widget. New WidgetBlueprints will still contain a Canvas Panel when created.

Change 3173966 on 2016/10/25 by Alex.Delesky

	#jira UE-20891 - SpinBox now receives MouseMove events while simulating touch events using the mouse.

Change 3174847 on 2016/10/26 by Alex.Delesky

	#jira UE-36371 - Windowed Fullscreen will now expand to fit the entirety of the current window and will not be displaced when the Windows taskbar is docked on the top or left sides of the screen.

Change 3174916 on 2016/10/26 by Alexis.Matte

	When re-importing fbx file, always log to the message log.
	#jira UE-37639

Change 3174940 on 2016/10/26 by Alex.Delesky

	Back out changelist 3174847 at request of platforms team. Was fixed on Main.

Change 3174995 on 2016/10/26 by Matt.Kuhlenschmidt

	Import commandlet fixes

	- Fixed crash when source control could not be contacted
	- Fixed assets not importing correctly if they depended on other assets in a previous import group within the automated import

Change 3175217 on 2016/10/26 by Alexis.Matte

	The FBX reimport animation code now return false if there was an error when importing
	#jira UE-37755

Change 3175728 on 2016/10/26 by Alexis.Matte

	Log a message when importing a skeletal mesh with more bone influence then the maximum supported
	#2875
	#jira UE-37613

Change 3177997 on 2016/10/28 by Nick.Darnell

	Editor - Prevent re-entrant calls when EndPlayMap is called.

Change 3178429 on 2016/10/28 by Nick.Darnell

	Engine - Bumping BaseEngine.ini to IOS_8, MinimumiOSVersion, as that is now the minimum allowed to fix an error on startup.  Tweaking the location of where some importing files go when they're imported.

Change 3179774 on 2016/10/31 by Matt.Kuhlenschmidt

	Guard against bad render targets in Slate RHI

	#jira UE-37905

Change 3179900 on 2016/10/31 by Matt.Kuhlenschmidt

	Added logging to track https://jira.it.epicgames.net/browse/UE-37900

	#jira UE-37900

Change 3179920 on 2016/10/31 by Alex.Delesky

	Removing LODs from skeletal meshes is now a transacted action and can be undone. Related to UE-25591.

	#jira none

Change 3179921 on 2016/10/31 by Alex.Delesky

	#jira UE-37725 - Adding safeguard against a potential crash in FTextureEditorViewportClient caused by a texture not having a valid texture resource

Change 3180119 on 2016/10/31 by Alexis.Matte

	fbx importer avoid asset creation name clash
	#jira UE-35100

Change 3181905 on 2016/11/01 by Alexis.Matte

	Paint tool now allow users to paint on any vertex if they need it.
	#jira UE-8372

Change 3182355 on 2016/11/01 by Alexis.Matte

	We now support FBX LODs export for the asset exporter from the content browser.
	#jira UE-35302

Change 3183286 on 2016/11/02 by Alexis.Matte

	Make sure static mesh build settings are set properly when we re-import with different options. Specifically the normals, tangents and tangent space are dependent on the import options.
	#jira UE-37520

Change 3183567 on 2016/11/02 by Shaun.Kime

	#jira UE-38019
	The Content Browser's View Options originally included both Engine and GameProject plugins only when clicking Show Plugin Content. Since there are quite a few Engine plugins, this produces quite a bit of content in the Folders panel. Most of the Engine plugins have classes or content that isn't really meant to be user-facing, so the experience of hunting for a game plugin-in's content is poor.

	The new behavior is that GameProject plugins are controlled by the "View Plugin Content" option. In order to see the Engine plugins you'll need both Engine Content and Plugin Content checkboxes enabled. By default, the editor should enable the "View Plugin Content" checkbox since it should be limited to just the content in the game's Plugins folder.

Change 3184002 on 2016/11/02 by Jamie.Dale

	Fixed crash during TSF IME shutdown

	#jira UE-38073

Change 3185126 on 2016/11/03 by Shaun.Kime

	Some of the plugin templates define Editor specific plugins. If created and a Standalone build is run, the application will attempt to link in editor libraries in game mode and will run into issues when you hit any key. The fix is to specify an Editor module description for these plugins.
	Additionally, there appears to be a mismatch in pathing types when dealing with plugin path and GameDir. Plugin path is absolute and GameDir is relative by default. We check to see if the gameDir is a subset of the plugin path, but this fails due to the mismatch. The fix is to force both to be absolute (enforcing normalization of both paths as well).

	#jira UE-38065
	#jira UE-37645

Change 3185278 on 2016/11/03 by Nick.Darnell

	UMG - Fixing some issues with HDPI mode in the widget designer.

Change 3185355 on 2016/11/03 by Nick.Darnell

	UMG - Widget Component's Draw At Desired size now should also work correctly if it's in screenspace.

Change 3185510 on 2016/11/03 by Nick.Darnell

	UMG - Restoring the ability of the Widget Component to directly recieve hardware input.  The Widget Interaction Component is great for just about every interaction use case - the one it's not is when you actually want the 3D widgets to take focus, and to be able to be typed directly into by the user.  The kind of situation where you might want to use them as a 3D menu, in a non-VR environment.  By default - Widget Components will not behave in this manner, but you can now use the option bReceiveHardwareInput to enable the ability for Widget Components to function more like a widget in the screenspace of the viewport.

	Slate - The scene viewport now correctly takes scale into account when drawing the 'software cursor', this fixes an issue with HDPI mode, and the cursor not being restored to the same location after moving a gizmo.

Change 3185514 on 2016/11/03 by Nick.Darnell

	UMG - Fixing some HDPI mode problems with widget position calculation when projecting world to viewport / screen, absolute spaces.

Change 3185652 on 2016/11/03 by Nick.Darnell

	Slate - Exposing a cached version of the widget geometry that comes in during Tick.  Also performed a bit of optimization work on the class to make some space for the geometry object we now cache, by compacting the pointer event delegates we were storing.

Change 3185952 on 2016/11/03 by Nick.Darnell

	UMG - Fixing another build error relating to local widget geometry.

Change 3185953 on 2016/11/03 by Nick.Darnell

	UMG - Fixing a mac compiler warning.

Change 3186886 on 2016/11/04 by Matt.Kuhlenschmidt

	Fixed collapse all hiding everything in the settings editors

	#jira UE-38151

Change 3187014 on 2016/11/04 by Matt.Kuhlenschmidt

	Fixed new assets opening in a minimized window not restoring that window.

Change 3187026 on 2016/11/04 by Shaun.Kime

	UUnrealEdEngine::edactDeleteSelected calls out to FBlueprintEditorUtils::FindActorsThatReferenceActor. This checks the entire world for each actor to be deleted. When you have tens of thousands of actors  in the world and are deleting tens of thousands of actors, this can take minutes. This change amortizes the cost of finding the actor references once for the world and for each actor to be deleted, we query the cached list of references. This brings the deletion time down to seconds.

	#jira UE-38094

Change 3187073 on 2016/11/04 by Nick.Darnell

	Automation - Changing the code that writes out json to force no BOM as is the json standard.

Change 3187113 on 2016/11/04 by Jamie.Dale

	Removed double look-up in UTextProperty::SerializeItem

Change 3187114 on 2016/11/04 by Jamie.Dale

	Feedback context now uses culture correct percentage formatting

Change 3187273 on 2016/11/04 by Alexis.Matte

	Fbx importer for static mesh, make sure that we order the materials array to follow the section order.
	Add also some fbx automation test
	#jira UE-38242

Change 3187276 on 2016/11/04 by Matt.Kuhlenschmidt

	Fix crash when an actor picker shows up in the struct editor.  Structs do not have root property nodes

	#jira UE-38268

Change 3187463 on 2016/11/04 by Nick.Darnell

	Automation - Updating the blessed screenshots, and fixing the BOM issues with the json.

Change 3188638 on 2016/11/07 by Shaun.Kime

	Making the UI for adding/removing parameters in custom blueprint functions behave similarly to the struct creation dialog in the content browser. There are no longer "New" buttons at the bottom of the panel and the parameter moving controls have been moved onto the main parameter row instead of being nested inside the collapse panel. A tooltip will now let you know the full parameter name and type when you hover over the editable name field. Made the move up/down icons more legible by increasing contrast between the arrow and the light grey background.
	#jira UE-38240

Change 3189056 on 2016/11/07 by Nick.Darnell

	Core/Editor - UObject::IsAsset() now returns false if the outermost package is RF_Transient.  Also updating the creation of the transient package to be RF_Transient.  This makes it so transient packages created by UMG or some other editor for things like previewing a streamed in level instance, no longer show up in the content browser.

Change 3189147 on 2016/11/07 by Jamie.Dale

	Fixed potential race-condition where a UFont object could be GC'd while the loading screen was using the font cache

	This queues up the pending removal until it's safe to execute it (by a thread that fully owns Slate rendering).

	#jira UE-38309

Change 3189344 on 2016/11/07 by Matt.Kuhlenschmidt

	Merging //UE4/Dev-Main to Dev-Editor (//UE4/Dev-Editor)

Change 3189380 on 2016/11/07 by Matt.Kuhlenschmidt

	Guard against null object when creating details panel

Change 3190017 on 2016/11/08 by Alexis.Matte

	FrontX support for scene importer
	#jira UETOOL-1061

Change 3190058 on 2016/11/08 by Matt.Kuhlenschmidt

	Fixed misaligned button in the new blueprint class dialog

Change 3190086 on 2016/11/08 by Nick.Darnell

	UMG - Fixing the calculation for widget componets screen position if the camera aspect is constrained.

Change 3190159 on 2016/11/08 by Nick.Darnell

	UMG - We no longer also take the platform DPI scale into account when applying UMG's UI scale.  Since UMG already provides a DPI scaling system, compounding it with the native OSes produces undesirable results, since the DPI scale curve does not take into account some unknown platform scale set by a user.

Change 3190161 on 2016/11/08 by Nick.Darnell

	UMG - UWidget is now Blueprintable.  Improving some doc.

Change 3190545 on 2016/11/08 by Alexis.Matte

	Support scaling when exporting skeleton (bind pose) to FBX
	#jira UE-36120

Change 3191614 on 2016/11/09 by Simon.Tourangeau

	Fix cooking crash after fbx import of a scene without meshes

	#jira UE-38264

Change 3191659 on 2016/11/09 by Simon.Tourangeau

	Cleanup Persona LOD section button layout

	#jira UE-38339

Change 3191882 on 2016/11/09 by Jamie.Dale

	Changed FBlackboardKeySelector::AddObjectFilter to use MakeUniqueObjectName so it generates more stable names, rather than relying on a static counter.

	Also updated FBlackboardKeySelector::AddClassFilter, FBlackboardKeySelector::AddEnumFilter, and FBlackboardKeySelector::AddNativeEnumFilter to use MakeUniqueObjectName to ensure they don't conflict.

Change 3192092 on 2016/11/09 by Jamie.Dale

	Deleting some test assets that were accidentally checked in, some of which no longer load

Change 3192281 on 2016/11/09 by Alex.Delesky

	#jira UE-31866 - Widget Blueprints will no longer experience compile issues when dragging widgets between the hierarchy views of different Widget Blueprints.

Change 3192365 on 2016/11/09 by Shaun.Kime

	Adding support for MaterialParameterCollections to Slate UI objects. For reasons of Blueprint controls amongst other things, MPC's are owned by individual UWorlds and transferred over to their respective Scenes. Since we want the latest values from those in-UWorld representations, Slate needs to know about the Scene on the render thread to properly map the materials to their MPC inputs. This involved keeping Scene arrays synchronized between the game logic thread and render thread, and adding a Scene index field to each batched draw element in Slate. SceneViewports are now responsible for registering their associated Scenes with the SlateRenderer. Since RetainerBoxes also draw their content as well, they too need to register their Scenes.

	#jira UE-19022

Change 3192494 on 2016/11/09 by Alex.Delesky

	#jira UE-37829 - Dynamically changing an option in the style for an Editable Text Box or Multiline Editable Text Box will now update it correctly.

Change 3193183 on 2016/11/10 by Alexis.Matte

	When doing FBX scene re-import, the new staticmesh asset was not mark as dirty. So the system was not saving the new asset.
	#jira UE-38450

Change 3193419 on 2016/11/10 by Alex.Delesky

	Fixing UnrealTournament build error in SUTChatEditBox

	#jira none

Change 3193456 on 2016/11/10 by Alex.Delesky

	Fix to build warning C6011 in SWidgetHierarchyItem

	#jira none

Change 3193704 on 2016/11/10 by Simon.Tourangeau

	Create Cinematic Camera when importing camera from fbx

	#jira UE-37764

Change 3194593 on 2016/11/11 by Nick.Darnell

	Slate - Fixing the window reshaping logic to avoid work if we don't need to do it, rather than external calls attempting to do the check (poorly).  This appears to fix the problem with popup menus being slightly off in size, creating scrollbars.  This also prevents constant reshaping of windows, due to people performing the wrong checks over and over, because they were comparing against non-truncated or rounded values against truncated/rounded values.

Change 3194595 on 2016/11/11 by Nick.Darnell

	Slate - Simplifying the Menu Anchor popup code for new Windows, and correcting it so that it does not take non-DPI scale into account when calculating the size of the window.  Otherwise, popup menus on say, the blueprint editor change size depending upon the scale of the area.

Change 3194830 on 2016/11/11 by Richard.TalbotWatkin

	Optimized pasting brushes, so geometry is not constantly rebuilt for every brush that's added.  This improves performance by a couple of orders of magnitude!
	#jira UE-38524 - Moving many brushes to another level is very slow

Change 3194859 on 2016/11/11 by Alexis.Matte

	Fix fbx skeletal mesh cleanup material crash
	#jira UE-38525

Change 3195199 on 2016/11/11 by Nick.Darnell

	UMG - Updating the bindable widget searching code in sequencer to use the WidgetTree traversing code, instead of something custom.  This fixes the issue where it wasn't finding widgets inside of named slots.

	#jira UE-38536

Change 3196579 on 2016/11/14 by Matt.Kuhlenschmidt

	Guard against rendering crashes when a mesh with no lod resources is opened.

	#jira UE-38520

Change 3196614 on 2016/11/14 by Nick.Darnell

	Slate - The ignore incoming scale option for the scale box should now behave as expected in more cases.  It required modifying the GetRelativeLayoutScale function to also pass down the prepass scale, otherwise it can't extract out the incoming scale ahead of time before text is measured ahead of time.

Change 3196624 on 2016/11/14 by Matt.Kuhlenschmidt

	PR #2927: UE-38473: Shadow outline color uses shadow color (Contributed by projectgheist)

Change 3196770 on 2016/11/14 by Matt.Kuhlenschmidt

	Ensure instead of crash when updating the selection pivot if a component's actor is not selected (this is non fatal)

	#jira UE-38544

Change 3196863 on 2016/11/14 by Nick.Darnell

	Slate - Allowing font outline settings to be specified in native code when constructing a SlateFontInfo via a ctor.

Change 3196900 on 2016/11/14 by Nick.Darnell

	Slate - Upgrading some cases that were using the older version of GetRelativeLayoutScale.

Change 3196947 on 2016/11/14 by Matt.Kuhlenschmidt

	Guard against crashes in the details panel when an OS message causes the tree to refresh when a previous event has invalidate the contents of the details panel.

	#jira UE-36499, UE-38497

Change 3197028 on 2016/11/14 by Alexis.Matte

	Shift Drag is not moving the camera when the user is dragging the 3 axis in same time.
	#jira UE-38382

Change 3197167 on 2016/11/14 by Matt.Kuhlenschmidt

	Removed pivot updating code per frame for now.  It changes on selection so I cant see a reason why it is needed every frame

Change 3197227 on 2016/11/14 by Nick.Darnell

	UMG/Blueprint - Exposing a way to set the default schema a blueprint editor derivation uses.  Updating all widget blueprints to finally use the WidgetGraphSchema.

Change 3197239 on 2016/11/14 by Nick.Darnell

	UMG - Improving the ReceiveHardwareInput option to limit exposure of widgets to hit testing that did not register for it.

Change 3197538 on 2016/11/14 by Nick.Darnell

	UMG - Making some progress on converting the schema over on load, now appear to correctly be loading it in time to be able to perform node conversions to convert older nodes to newer nodes.  Required changing the UBlueprint interface to have a virtual for upgrading nodes, that could be overriden in WidgetBlueprint to make sure the schemas have all been updated, as Serialize is too early, and PostLoad is too late.

Change 3198211 on 2016/11/15 by Matt.Kuhlenschmidt

	Guard against reimport factories being deleted while in use

	#jira UE-37577

Change 3198589 on 2016/11/15 by Alex.Delesky

	#jira UE-38527 - Curves editors will no longer crash when trying to scale to fit after resetting the curve to its default values. This also fixes an issue where selecting a key before resetting the curve to default would sometimes cause the timestamp to display for a now-invalid key.

Change 3198783 on 2016/11/15 by Nick.Darnell

	The Widget Component's Allow Hardware Input should now correctly convert coordinates coming from a viewport scaled up by the OS DPI scaling code.

Change 3198933 on 2016/11/15 by Jamie.Dale

	Changing the package localization ID used by a package now marks the package as dirty

Change 3198942 on 2016/11/15 by Jamie.Dale

	Clearing the package localization ID used by a package now marks the package as dirty

Change 3200241 on 2016/11/16 by Shaun.Kime

	Now allowing users to customize the Class Browser/Picker to filter out developer folders as well as hide internal use classes via INI settings. A ViewOptions button has been added to allow users to choose whether or not these filters are enabled.
	By default, internal only classes will be hidden and you will be limited to your own developer folder.

	Example change to DefaultEngine.ini or BaseEngine.ini to hide some classes as internal use
	[/Script/ClassViewer.ClassViewerProjectSettings]
	+InternalOnlyPaths=(Path="/Engine/VREditor")
	+InternalOnlyClasses=/Script/VREditor.VREditorBaseUserWidget

	The InternalOnlyPaths example will hide any classes in the VREditor folder or subfolders.
	The InternalOnlyClasses example will hide any classes that derive from VREditorBaseUserWidget.

	Both can be edited by the project settings UI so no manual INI tweaking is required. Please go to Project Settings->Class Viewer->Class Visibility Management

	#jira UE-38313

Change 3200621 on 2016/11/16 by Matt.Kuhlenschmidt

	Adding missing change needed post merge from main

Change 3200968 on 2016/11/16 by Jamie.Dale

	Fixed localization gather including texts that were instanced or otherwise unchanged

	- It now uses the archetype when exporting to diff against the default property value, and will only gather text that has changed from the default.
	- UMG widgets that are instanced from another UMG asset now only gather overridden values, and skip all child instances.

Change 3201033 on 2016/11/16 by Cody.Albert

	Fixed source control to properly notify when files need to be checked out if a blueprint node is dragged

Change 3201829 on 2016/11/17 by Shaun.Kime

	Fixing issue where GEngine is null in early game loading, potentially causing a crash.

Change 3201832 on 2016/11/17 by Matt.Kuhlenschmidt

	Fix build warning

Change 3201835 on 2016/11/17 by Nick.Darnell

	Slate - Making it so explictly focusing a slate user that does not yet exist, creates the slate user so that the state is properly maintained in prepartion for that user's arrival / input.

Change 3201947 on 2016/11/17 by Matt.Kuhlenschmidt

	Fix streaming pause rendering starting a movie if a movie was already playing

Change 3202089 on 2016/11/17 by Nick.Darnell

	Editor - When replacing references, code that was added in 2729702, was allowing redirectors to be created that then might be abandoned and not renamed later if there was a collision on object name.  There's no problem if two objects have the same name, as long as they have different paths (except for classes).  So now the code records object paths in a seperate set, and avoids reprocessing / and creating multiple redirectors for the same objects, instead of just using object name.

Change 3202139 on 2016/11/17 by Jamie.Dale

	Fix for adjusting text spacing when lines are removed from TextLayouts

Change 3202398 on 2016/11/17 by Cody.Albert

	Updated UMG Sequencer to properly fire events once per loop

Change 3202591 on 2016/11/17 by Shaun.Kime

	Fixing coding standards violations.

Change 3202744 on 2016/11/17 by Shaun.Kime

	StaticMeshComponent's OverriddenLightMapRes current displays the value it was set to, even when the bOverrideLightMapRes is false. The behavior within  UStaticMeshComponent::GetLightMapResolution is to use the LightMapResolution on the StaticMesh member instead when bOverrideLightMapRes is false. The UI was adjusted to reflect the more accurate behavior.

	#jira UE-38315

Change 3203009 on 2016/11/17 by Alex.Delesky

	Backing out changelist 3170522 per request

	#jira UE-33031

Change 3204077 on 2016/11/18 by Nick.Darnell

	Automation - Updating several bits of the screenshot automation piece to work a bit better, show names if we have them, and show preview dialogs for images.

Change 3204086 on 2016/11/18 by Jamie.Dale

	Added FGCObjectScopeGuard and TStrongObjectPtr as a convenient way to keep a UObject alive without having to add it to the root-set

	Both use FGCObject internally to reference the object and keep it alive.

	FGCObjectScopeGuard is designed to be lean and used as a guard for an existing pointer, whereas TStrongObjectPtr is more "full-fat" and designed to be a replacement for a raw-pointer.

	You should prefer FGCObjectScopeGuard where possible. Also note that TStrongObjectPtr isn't supported by UHT/UPROPERTY as you should just use a raw-pointer in that case (it would do the same thing).

Change 3204189 on 2016/11/18 by Alex.Delesky

	Removing content from dev folder

Change 3204205 on 2016/11/18 by Jamie.Dale

	Fix for being unable to delete folders that still have sub-folders in the Content Browser

	#jira UE-38752

Change 3204270 on 2016/11/18 by Simon.Tourangeau

	Fix StaticMesh socket reimports
	- socket transforms are now updated correctly on reimport
	- deleted socket from source will be removed on reimport
	- fix SocketManager refresh after import

	#jira UE-38195

Change 3204283 on 2016/11/18 by Alex.Delesky

	#jira UE-38314 - Undoing a change in the Preview Scene Viewer in Static Mesh Editor will now properly update changes within the scene itself.

Change 3205757 on 2016/11/21 by Jamie.Dale

	PR #2923: Slate: Fixed bug where NumCharactersInGlyph was set incorrectly for TAB characters (Contributed by pluranium)

Change 3205759 on 2016/11/21 by Matt.Kuhlenschmidt

	PR #2958: Handle legacy Windows exe icon location (Contributed by projectgheist)

Change 3205816 on 2016/11/21 by Matt.Kuhlenschmidt

	PR #2956: Add plane to basicshapes (Contributed by tommybear)

Change 3205831 on 2016/11/21 by Jamie.Dale

	Speculative fix for UE-38492

	This guards against null objects being passed to FAssetDeleteModel, as well as objects that become null due to the GC that happens in FAssetDeleteModel.

	#jira UE-38492

Change 3205869 on 2016/11/21 by Alex.Delesky

	#jira UE-38227 - Trying to transform a component on a blueprint while a spline mesh actor has the transform gizmo active in the editor will no longer modify the spline mesh actor

Change 3205873 on 2016/11/21 by Alex.Delesky

	#jira UE-38379 - When editing a row in the data table, clicking on a different row before committing changes will now switch to that row. This also fixes the issue of data tables constantly regenerating cell widgets on data changes.

	Should also address the issue mentioned in #jira UE-32965

Change 3205954 on 2016/11/21 by Shaun.Kime

	Reverting changes from 3202744 that allowed override properties to show up as real properties in the list. There are several detail panel customizations that don't deal with this properly and rather than force everyone to upgrade, we'll just modify the static mesh detail customization to do the work.

	#jira UE-38315

Change 3205965 on 2016/11/21 by Alex.Delesky

	#jira UE-38749, UE-38755 - Space and Enter should now fire button OnClicked events when a button is focused

	PR #2942

Change 3207157 on 2016/11/22 by Chris.Wood

	Added UnrealWatchdog tool, run by the Editor, to improve abnormal shutdown tracking.
	[UE-32952] - Watchdog - Show CRC when reporting abnormal shutdowns in internal builds

Change 3207344 on 2016/11/22 by Matthew.Griffin

	Added UnrealWatchdog to the Binary Release

Change 3207396 on 2016/11/22 by Ben.Marsh

	Add UnrealWatchdog to UGS precompiled binaries for Odin and Orion.

Change 3207418 on 2016/11/22 by Matt.Kuhlenschmidt

	Redid blur changes from Paragon Dev-General

	Blur widget updates
	- Renamed to SBackgroundBlur/UBackgroundBlur
	- Split SBackgroundBlur out into its own file
	- Added bApplyAlphaToBlur - when true, the strength of the blur is modulated by the widget alpha
	- Updated BlurRadius to be TOptional, so we auto-calculate radius when it isn't set
	- Added a UBackgroundBlurSlot, but left it unattached so it can be done in dev-editor (and update based on the engine version)
	- Updated OrionBlurWidget to export dll symbols and set up default low quality fallback image

Change 3207443 on 2016/11/22 by Chris.Wood

	Fix CIS error on Mac from my change CL 3207157

Change 3207702 on 2016/11/22 by Matt.Kuhlenschmidt

	Added missing files

Change 3207958 on 2016/11/22 by Matt.Kuhlenschmidt

	Guard against crash clearing scenes from the slate RHI renderer during movie loading code.

Change 3207962 on 2016/11/22 by Matt.Kuhlenschmidt

	Added a guard against the rendering thread timing out while on a breakpoint by checking if the debugger is present before performing the timeout check

Change 3208194 on 2016/11/22 by Matt.Kuhlenschmidt

	Actually call correct method of checking for a debugger

Change 3209139 on 2016/11/23 by Cody.Albert

	Adding support for "Show Only Modified Properties" filter to DetailWidgetRow

Change 3209206 on 2016/11/23 by Jamie.Dale

	Moving folders now removes the old folder from disk if it's empty

	This had already been done for deleting folders, but moving them was missed.

	#jira UE-11796

Change 3209281 on 2016/11/23 by Jamie.Dale

	PR #2932: Fix crash while updating cursor highlight (Contributed by nakosung)

Change 3210383 on 2016/11/25 by Chris.Wood

	Documented Crash Report Client analytics events
	[UE-32787] - Document Crash Report Client analytics events in code

Change 3210385 on 2016/11/25 by Alexis.Matte

	Make sure the combine mesh option of the staticmesh import is stored in staticmeshimportdata so the re-import know if it must re-import in combined or not
	#jira UE-38925

Change 3210983 on 2016/11/28 by Matt.Kuhlenschmidt

	Merging //UE4/Dev-Main to Dev-Editor (//UE4/Dev-Editor)

Change 3211001 on 2016/11/28 by Matt.Kuhlenschmidt

	Fix build errors

Change 3211009 on 2016/11/28 by Matt.Kuhlenschmidt

	PR #2960: Git plugin: multiline initial commit message and other connect screen cleanup (Contributed by SRombauts)

Change 3211017 on 2016/11/28 by Matt.Kuhlenschmidt

	Fix ATSC texture compression quality tooltip

	#jira UE-38996

Change 3211045 on 2016/11/28 by Matt.Kuhlenschmidt

	Fix compile errors

Change 3211081 on 2016/11/28 by Matt.Kuhlenschmidt

	Fix post process anim blueprints on skeletal meshes not being clearable

	#jira UE-39017

Change 3211094 on 2016/11/28 by Matt.Kuhlenschmidt

	Added more logging for jira UE-39000

	#jira UE-39000

Change 3211284 on 2016/11/28 by Matt.Kuhlenschmidt

	Redid fix for UE-35822 in dev-editor

Change 3211544 on 2016/11/28 by Matt.Kuhlenschmidt

	Fix deprecation warning

Change 3211769 on 2016/11/28 by Matt.Kuhlenschmidt

	Disable motion blur in editor views by default

	#jira 38424

Change 3211776 on 2016/11/28 by Matt.Kuhlenschmidt

	Fix PS4 compile errors

Change 3211949 on 2016/11/28 by Matt.Kuhlenschmidt

	Details panels changes
	- Added the ability to create groups within groups in details panel customizations
	- Added the ability for struct customizations to add categories to the parent

Change 3211954 on 2016/11/28 by Matt.Kuhlenschmidt

	Reorganized the post process settings so they appear as categories in the parent and so that they have better categories to make it clear what all the settings do.

Change 3213158 on 2016/11/29 by Jamie.Dale

	Updated User Defined Enum display names to use real FText instances so they can have stable keys

	This avoids the issue where the FText display names were cached from an FString, resulting in them having a different identity each time they were re-cached, which lead to localization and deterministic cooking issues.

	User Defined Enums no longer use meta-data to store their display names, and instead use a TMap in UUserDefinedEnum to map the raw enum entry name to its friendly display name. In addition to this, the enum editor has been updated to use STextPropertyEditableTextBox, which will keep the keys used by the display names stable where possible (allowing for delta-localization and historic tracking).

	#jira UE-26274

Change 3213172 on 2016/11/29 by Jamie.Dale

	Adding experimental support for content hot-reloading

	The underlying support for this is in CoreUObject (see ReloadPackage and ReloadPackages in UObjectGlobals.h/.cpp), with editor specific support being added via PackageTools::ReloadPackages, and also hooks registered with FCoreUObjectDelegates::OnPackageReloaded (eg, UEditorEngine::HandlePackageReloaded).

	The basic workflow for package reloading is as follows:
	 1) The current package is renamed, and the RF_NewerVersionExists flag is added to it and all its sub-objects.
	 2) The new package is loaded. Should this fail the old package is renamed back, and the RF_NewerVersionExists flag is removed.
	 3) We generate a mapping between objects in the old package and objects in the new package (see UObject::BuildSubobjectMapping).
	 4) We enumerate every object in memory, and fix-up any serialized or ARO object pointers referencing something from the old package, to reference the equivalent object from the new package (or null if no object could be found).
	 5) We run a GC, and verify that the old package was purged (printing any lingering references if it wasn't).

	For efficiency reasons package reloading may be run in batches (the editor uses batches of 500), as this allows package reloading to happen faster (as the reference fix-up and GC only happens once per-batch) at the cost of consuming more memory.

	In-editor there is an experimental setting to enable content hot-reloading. When this is enabled the SCC operations in the Content Browser will use content hot-reloading, rather than attempt to unload the reload the package as separate operations (which often fails). In order to allow the external SCC program to overwrite the files on disk, the linkers are detached from any packages that will be replaced prior to invoking the internal SCC operation.

Change 3213428 on 2016/11/29 by Jamie.Dale

	Implemented clamping on FTextInputMethodContext::SetSelectionRange to fix an issue where composition could provide an invalid range if the text was changed while composing

	#jira UE-37746

Change 3213442 on 2016/11/29 by Jamie.Dale

	Workaround for a bug in TSF based MS IMEs on Windows 8+

	They omit calling GetSelection and instead expect QueryInsert to return the current selection range. This also seems to fix an issue where composition no longer worked once some text had been deleted.

	#jira UE-37309

Change 3213603 on 2016/11/29 by Cody.Albert

	Changed PanelWidget::RemoveChildAt to not release slate resources if the child is a UserWidget

	#jira UE-39106

Change 3213633 on 2016/11/29 by Matt.Kuhlenschmidt

	Attempt to fix includetool cis warning

Change 3215159 on 2016/11/30 by Jamie.Dale

	Fixing MakeShared forward declaration

Change 3215220 on 2016/11/30 by Alex.Delesky

	#jira UE-38698 - Deleting a widget from the Widget Blueprint Hierarchy (or adding a new widget to the hierarchy directly) will no longer cause the scroll bar to return to the top of the hierarchy view.

Change 3215390 on 2016/11/30 by Jamie.Dale

	Maps now end a hot-reload batch

Change 3215394 on 2016/11/30 by Matt.Kuhlenschmidt

	Updating guard to track down worlds that have no package as an outer

	#jira UE-35712

Change 3215500 on 2016/11/30 by Alexis.Matte

	Color grading widget customization
	#jira UETOOL-1070

Change 3215519 on 2016/11/30 by Jamie.Dale

	Fixed crash caused by using TextNamespaceUtil::EnsurePackageNamespace in 'game' mode

Change 3215556 on 2016/11/30 by Cody.Albert

	Fixed issue where check-out toast would not disappear

	#jira UE-39146

Change 3215585 on 2016/11/30 by Jamie.Dale

	Adding an explicit ESPMode to MakeShared to try and placate Android

Change 3215737 on 2016/11/30 by Alexis.Matte

	Fix build warning

Change 3215748 on 2016/11/30 by Matt.Kuhlenschmidt

	Guard against crashes due to duplicate items in the scene outliner if actors somehow end up attached to themselves

	#jira UE-35935

Change 3215758 on 2016/11/30 by Ben.Marsh

	Add a 'Custom...' build type for Dev-Editor.

Change 3216183 on 2016/11/30 by Alexis.Matte

	Fix win32 build error

Change 3216362 on 2016/11/30 by Matt.Kuhlenschmidt

	Fix mac build error.

Change 3216828 on 2016/12/01 by Jamie.Dale

	Fixing MakeShared on Android

	#jira UE-39204

Change 3216839 on 2016/12/01 by Matt.Kuhlenschmidt

	PR #2997: Spelling fix for Actor.h's description of bEnableAutoLODGeneration. (Contributed by hgamiel)

Change 3216842 on 2016/12/01 by Matt.Kuhlenschmidt

	Remove the ensure when pushing absolute transforms onto a canvas matrix stack.  We can handle this properly now by just adding the transform to the stack if the stack is empty

	#jira UE-36496

Change 3216874 on 2016/12/01 by Matt.Kuhlenschmidt

	Fix a number of keybindings problems
	- Removed editor keybindings from project settings.  It should not have been in there (already in editor settings)
	- Removed duplicate registration of editor keybindings from editor settings
	- Fixed memory leak regenerating keybinding widgets when ending PIE world.
	- Cleaned up styling a bit to make keybindings widgets clearer.

	#jira UE-39211, UE-38718

Change 3216881 on 2016/12/01 by Shaun.Kime

	Added support for reroute nodes to the material editor. These nodes should function identically to their counterparts in Blueprints. A new UMaterialExpression, UMaterialExpressionReroute has been added. It inserts no HLSL code, and instead just moves along its input to find the real UMaterialExpression that it is ultimately bound to.
	Since the material system serializes its data as UMaterialExpressions, a more generalized approach across graph types isn't available as only the visual UI layer is shared between blueprints and material graphs.

	Also modified the material palette and popup material expression menu to allow for c++ based material name and description customization. If we choose to expand this, it would make the C++ material nodes more discoverable and understandable.

	Manually pulled in CL 3200823 and 3208490 to get bugfixes around material attribute usage.

	Adding an reroute node should function identically to Blueprints (ie double-click on connection to add or Utility\Add Reroute Node from palette). You should be able to add as many reroute nodes as you want in a chain. A reroute node that only has a connected output and not an input should behave as if there were no reroute node present (i.e. triggering constants on Add). It should be possible to use reroute nodes between any two supported node types if they are connectable in isolation. Where possible, we should show the same type mismatch errors that you'd see if connecting nodes directly (ie dragging a boolean constant into a reroute node connected to an Add should result in a Float/Bool mismatch). A reroute node is purely visual, it should have no impact on the final instruction count.

	In the event that an incomplete reroute input was completed by dragging to an invalid type, I tried to guarantee that the compiler would generate the appropriate errors. This can happen because we only know the inputs to a given node in code. If a reroute node doesn't have an input, it does not know what type it should be. However, the compiler should still detect these bad cases and error out.

	#jira UE-6882

Change 3216968 on 2016/12/01 by Jamie.Dale

	Syncing via source control now unloads (rather than reloads) packages that have been deleted from disk

Change 3216970 on 2016/12/01 by Jamie.Dale

	Reverting files now uses hot-reloading (if enabled)

Change 3217233 on 2016/12/01 by Jamie.Dale

	You can now choose to reload dirty packages via content hot-reloading

	This will revert any in-memory changes to the asset, which may be useful when you want to roll it back to its initial state without restarting the editor.

Change 3217244 on 2016/12/01 by Matt.Kuhlenschmidt

	WindowsMoviePlayer:  Initialize the movie player texture on first frame regardless of whether or not the decoder has a sample ready.  This prevents a white texture from showing up for a frame.

Change 3217466 on 2016/12/01 by Jamie.Dale

	Fixed a bug where FTextFormatData::ConditionalCompile_NoLock would always compile the text even if it was up-to-date

Change 3217572 on 2016/12/01 by Jamie.Dale

	Using FText::Format with an invalid argument no longer strips any associated argument modifier data from the resultant formatted text

Change 3217688 on 2016/12/01 by Jamie.Dale

	Fixed crash reloading the active world package when it was dirty

	#jira UE-39250

Change 3217978 on 2016/12/01 by Matt.Kuhlenschmidt

	Fixed crash where the slate renderer holds into scenes during maps are loaded causing access to deleted data after the load is complete.  We clean up cached scenes each frame but if slate doesnt tick the scenes are not cleaned up.  This change moves the CleanupScenes code to a location that is called each tick and during map loads

	#jira UE-39243

Change 3218834 on 2016/12/02 by Alexis.Matte

	move some scene conversion import fbx options to staticmesh, skeletalmesh and animation import data so the re-import will have acces to those import options
	#jira UE-38672

Change 3218838 on 2016/12/02 by Matt.Kuhlenschmidt

	Fixed editing static mesh settings manually in the details panel not visually refreshing the collision primitives

	#jira UE-39246

Change 3218864 on 2016/12/02 by Matt.Kuhlenschmidt

	Fixed basic cube shape having a convex hull instead of a box for collision

Change 3218900 on 2016/12/02 by Matt.Kuhlenschmidt

	Move static mesh collision properties to the collision category

Change 3219143 on 2016/12/02 by Michael.Dupuis

	#jira UE-39124 We can now place single mesh at a time
	#jira UE-39125 We can paint on the current level of the level containing the mesh we're painting on
	Change the way GetRandomVectorInBrush generate the Start/end position to use the BrushNormal instead of the BrushDirection

Change 3219199 on 2016/12/02 by Matt.Kuhlenschmidt

	Fixed a crash when changing Physical Surface Name and reassigning it on a physical material that uses it

	#jira UE-37452

Change 3219358 on 2016/12/02 by Alexis.Matte

	Fix fbx automation tests

Change 3219362 on 2016/12/02 by Alexis.Matte

	Support for MAX multisub material
	#jira UE-38467
	#jira UE-38471

Change 3219774 on 2016/12/02 by Jamie.Dale

	PR #2888: Add a setting to allow the Sources Panel to expand by default (Contributed by BhaaLseN)

Change 3219793 on 2016/12/02 by Jamie.Dale

	SWindow now restores focus back to the widget that last had focus when it was deactivated

	#jira UE-38965

Change 3221272 on 2016/12/05 by Matt.Kuhlenschmidt

	UI background blur tweaks
	- Adjust the downsample amount for lower kernel sizes
	- Flush post process memory used by the blur when switching levels

Change 3221273 on 2016/12/05 by Matt.Kuhlenschmidt

	Added guards against accesing scene caching methods of the slate resource manager on the rendering thread

Change 3221392 on 2016/12/05 by Matt.Kuhlenschmidt

	Added basic support for playing safe movies very early in the engine startup sequence.  A movie is considered safe to play very early if it is just a movie file and not some complex slate based UI loading screen

	no platform actually supports this yet as none of the movie streamer modules are loaded early enough and many platforms cant render this early

	Set PLATFORM_SUPPORTS_EARLY_MOVIE_PLAYBACK to 1 for your platform if it supports early loading

Change 3221831 on 2016/12/05 by Jamie.Dale

	Fixed UNumericProperty::ReadEnumAsUint8 not considering enum redirects when resolving the name

Change 3221986 on 2016/12/05 by Jamie.Dale

	Added an "Inline" font loading method

	This can be used in a cooked build to store the font data within the Font Face asset itself (rather than a separate .ufont file) in order to guarantee a hitch free load, at the cost of potentially using more memory up-front.

	The existing "PreLoad" loading method has been renamed to "LazyLoad" to better reflect what it actually does.

	This also fixes a bug where FFontData::Serialize could try and use the referenced Font Face asset before it had been fully loaded.

Change 3222065 on 2016/12/05 by Jamie.Dale

	Added log warning to detect hitches when lazily loading fonts

Change 3222225 on 2016/12/05 by Jamie.Dale

	Fixing style-set typo

	#jira UE-39333

Change 3223169 on 2016/12/06 by Matt.Kuhlenschmidt

	Fix autosaving prompting to check out built data if the built data asset was dirty during autosave

	#jira UE-39295

Change 3223184 on 2016/12/06 by Alexis.Matte

	Support LOD group and combine mesh
	#jira UE-1088

Change 3223212 on 2016/12/06 by Alex.Delesky

	#jira UE-39260 - TMap and TSet struct values should now be editable when editing a component's properties.

Change 3223215 on 2016/12/06 by Alex.Delesky

	#jira UE-38594 - The Widget Interaction Component will now default to tick while paused. Widget Components now contain a flag that will either allow or disallow interacting with them while the game is paused, which defaults to false.

Change 3223249 on 2016/12/06 by Matt.Kuhlenschmidt

	Added back in missing code that was lost in a merge

Change 3223271 on 2016/12/06 by Alex.Delesky

	#jira UE-38786 - The Color Picker will no longer stretch across the screen when exceptionally long strings are either entered or pasted inside one of the spin boxes. This also fixes an issue with editable text fields not validating string input on paste and will now prevent invalid data from being pasted inside a editable text block (e.g., pasting the string "I am a float" inside a spin box).

Change 3223275 on 2016/12/06 by Matt.Kuhlenschmidt

	Fixed a race condition in WEX where the loading screen would render an external UI window that was referencing deleted materials

Change 3223276 on 2016/12/06 by Alexis.Matte

	Staticmesh socket fbx import.
	#jira UE-38284

Change 3223363 on 2016/12/06 by Alexis.Matte

	Reimport must ask for missing file when re-importing a old asset that has no source files
	#jira UE-39356

Change 3223423 on 2016/12/06 by Chris.Wood

	Added option to place canvas panel children in same layer using explicit ZOrder setting.
	[UETOOL-935] - Figure out a solution for canvas panel batching

Change 3223551 on 2016/12/06 by Alexis.Matte

	UI mesh paint optimization, the slider now do not destroy the paint geometry adapter if the painted LOD has not change
	#jira UE-39383

Change 3223844 on 2016/12/06 by Matt.Kuhlenschmidt

	Back out change to change the defaults on vector and scalar expressions because this affects existing expressions that have not overridden the default

Change 3223880 on 2016/12/06 by Matt.Kuhlenschmidt

	Update doc links for maps and sets

Change 3224746 on 2016/12/07 by Michael.Dupuis

	#jira UE-39409 : Was'nt calling EndFoliageBrushTrace causing the transaction to never finish causing both jiras
	#jira UE-39410 : Was'nt calling EndFoliageBrushTrace causing the transaction to never finish causing both jiras

Change 3224826 on 2016/12/07 by Michael.Dupuis

	#jira UE-39095 : If a tool is active we simply consider inputs as handled to prevent this kind of behavior

Change 3224827 on 2016/12/07 by Simon.Tourangeau

	Improve search for material match on fbx mesh import
	- Add option to specify material search locations on mesh import
	- On Import it will now perform a first match material search in the following order	(suppose we are importing into /Game/Content/Assets/Meshes/MyMesh)
	   - Using Local as a search location will provide same behavior as before	(search non recursively in /Game/Content/Assets/Meshes)
	   - If option is UnderParent or more, search recursively in destination folder	(search recursively in /Game/Content/Assets/Meshes)
	   - If option is UnderParent or more, then recursively from parent folder	(search recursively in /Game/Content/Assets)
	   - If option is UnderRoot or more, search recursively from root folder	(search recursively in /Game)
	   - If option is AllAssets, search in every asset folder		(Search recursively everywhere)

	#jira UE-39020

Change 3224989 on 2016/12/07 by Chris.Wood

	Fixed black callstack text in CrashReportClient.
	[UE-38987] - CrashReportClient Callstack text is rendering Black

Change 3225142 on 2016/12/07 by Jamie.Dale

	Added collapsing methods when exporting text for translation

	You can now choose how to collapse your text for translation from three export modes:
	 - ELocalizedTextCollapseMode::IdenticalTextIdAndSource - Collapse texts with the same text identity (namespace + key) and source text (default 4.15+ behavior).
	 - ELocalizedTextCollapseMode::IdenticalPackageIdTextIdAndSource - Collapse texts with the same package ID, text identity (namespace + key), and source text (4.14 behavior).
	 - ELocalizedTextCollapseMode::IdenticalNamespaceAndSource - Collapse texts with the same namespace and source text (legacy pre-4.14 behavior).

	The new default allows you to re-use the same text identity in different packages without having to translate the same text multiple times, and you can also now opt to get back to the legacy pre-4.14 behavior of collapsing all identical texts within the same namespace (in case you were reliant on that behavior).

	You can change this setting via the Localization Dashboard, or add it to your gather configs as "LocalizedTextCollapseMode" (this needs to go into any configs that deal with exporting or importing PO files - the default if nothing is specified is "ELocalizedTextCollapseMode::IdenticalTextIdAndSource").

Change 3225509 on 2016/12/07 by Simon.Tourangeau

	Static analysis fix, false positive

Change 3225859 on 2016/12/07 by Matt.Kuhlenschmidt

	Fix broken physical surface details customization
	- Scrolling now works properly
	- Edit boxes dont change size while editing
	- properly checks out or makes file writable once an edit has been made

	#jira UE-39279

Change 3226840 on 2016/12/08 by Jamie.Dale

	Fixing a bug in FText formatting where it would ignore the rebuild and Rebuild as Source arguments for the format string itself

	#jira OPP-6485

Change 3226940 on 2016/12/08 by Alexis.Matte

	Avoid changing the W value when playing with the color grading wheel.
	#jira UE-39473

Change 3227814 on 2016/12/08 by Matt.Kuhlenschmidt

	 Temp disable lazy load font warnings to prevent infinite  recursion crashes at startup

Change 3228010 on 2016/12/08 by Matt.Kuhlenschmidt

	Fix for iOS compiling

Change 3228597 on 2016/12/09 by Jamie.Dale

	Removed hard dependency between UFont and UFontFace during struct serialization as it doesn't work with the EDL

	#jira UE-39529

Change 3228607 on 2016/12/09 by Jamie.Dale

	Fixed infinite recursion caused by logging while the output log font was still being loaded

	#jira UE-39523

Change 3228770 on 2016/12/09 by Jamie.Dale

	Fixed UUserDefinedEnum::GetEnumText

	it was using GetNameByIndex (which includes C++ scoping), rather than GetEnumName (which doesn't). This was causing all name look-ups to fail.

	#jira UE-39531

Change 3228785 on 2016/12/09 by Matt.Kuhlenschmidt

	Fix static analysis warning

[CL 3229477 by Matt Kuhlenschmidt in Main branch]
2016-12-09 15:05:28 -05:00

3692 lines
114 KiB
C++
Raw Blame History

// Copyright 1998-2017 Epic Games, Inc. All Rights Reserved.
#include "LaunchEngineLoop.h"
#include "HAL/PlatformStackWalk.h"
#include "HAL/PlatformOutputDevices.h"
#include "Misc/MessageDialog.h"
#include "Misc/ScopedSlowTask.h"
#include "Misc/QueuedThreadPool.h"
#include "HAL/FileManager.h"
#include "HAL/PlatformAffinity.h"
#include "Misc/FileHelper.h"
#include "Internationalization/TextLocalizationManagerGlobals.h"
#include "Logging/LogSuppressionInterface.h"
#include "Async/TaskGraphInterfaces.h"
#include "Misc/TimeGuard.h"
#include "Misc/Paths.h"
#include "Misc/ConfigCacheIni.h"
#include "Misc/OutputDeviceHelper.h"
#include "Misc/OutputDeviceRedirector.h"
#include "Misc/AutomationTest.h"
#include "Misc/CommandLine.h"
#include "Misc/App.h"
#include "Misc/OutputDeviceConsole.h"
#include "HAL/PlatformFilemanager.h"
#include "Templates/ScopedPointer.h"
#include "HAL/FileManagerGeneric.h"
#include "HAL/ExceptionHandling.h"
#include "Stats/StatsMallocProfilerProxy.h"
#include "HAL/PlatformSplash.h"
#include "HAL/ThreadManager.h"
#include "ProfilingDebugging/ExternalProfiler.h"
#include "Containers/Ticker.h"
#include "Interfaces/IPluginManager.h"
#include "ProjectDescriptor.h"
#include "Interfaces/IProjectManager.h"
#include "Misc/UProjectInfo.h"
#include "Misc/EngineVersion.h"
#include "HAL/IOBase.h"
#include "Misc/CoreDelegates.h"
#include "Modules/ModuleManager.h"
#include "Runtime/Launch/Resources/Version.h"
#include "VersionManifest.h"
#include "UObject/DevObjectVersion.h"
#include "HAL/ThreadHeartBeat.h"
#include "Misc/NetworkVersion.h"
#include "UniquePtr.h"
#if WITH_COREUOBJECT
#include "Internationalization/PackageLocalizationManager.h"
#include "Misc/PackageName.h"
#include "Misc/StartupPackages.h"
#include "UObject/UObjectHash.h"
#include "UObject/Package.h"
#include "UObject/Linker.h"
#endif
#if WITH_EDITOR
#include "EditorStyleSet.h"
#include "Misc/RemoteConfigIni.h"
#include "EditorCommandLineUtils.h"
#include "Input/Reply.h"
#include "Styling/CoreStyle.h"
#include "RenderingThread.h"
#include "Editor/EditorEngine.h"
#include "UnrealEdMisc.h"
#include "UnrealEdGlobals.h"
#include "Editor/UnrealEdEngine.h"
#include "Settings/EditorExperimentalSettings.h"
#include "Interfaces/IEditorStyleModule.h"
#if PLATFORM_WINDOWS
#include "AllowWindowsPlatformTypes.h"
#include <objbase.h>
#include "HideWindowsPlatformTypes.h"
#endif
#endif
#if WITH_ENGINE
#include "Engine/GameEngine.h"
#include "UnrealClient.h"
#include "Engine/LocalPlayer.h"
#include "GameFramework/PlayerController.h"
#include "GameFramework/GameUserSettings.h"
#include "Features/IModularFeatures.h"
#include "GameFramework/WorldSettings.h"
#include "SystemSettings.h"
#include "EngineStats.h"
#include "EngineGlobals.h"
#include "AudioThread.h"
#include "Interfaces/IAutomationControllerModule.h"
#include "Database.h"
#include "DerivedDataCacheInterface.h"
#include "ShaderCompiler.h"
#include "DistanceFieldAtlas.h"
#include "GlobalShader.h"
#include "Materials/MaterialInterface.h"
#include "TextureResource.h"
#include "Engine/Texture2D.h"
#include "SceneUtils.h"
#include "ParticleHelper.h"
#include "PhysicsPublic.h"
#include "PlatformFeatures.h"
#include "DeviceProfiles/DeviceProfileManager.h"
#include "Commandlets/Commandlet.h"
#include "EngineService.h"
#include "ContentStreaming.h"
#include "HighResScreenshot.h"
#include "Misc/HotReloadInterface.h"
#include "ISessionServicesModule.h"
#include "Net/OnlineEngineInterface.h"
#include "Internationalization/EnginePackageLocalizationCache.h"
#include "Rendering/SlateRenderer.h"
#include "Layout/WidgetPath.h"
#include "Framework/Application/SlateApplication.h"
#include "IMessagingModule.h"
#include "Engine/DemoNetDriver.h"
#if !UE_SERVER
#include "IHeadMountedDisplayModule.h"
#include "HeadMountedDisplay.h"
#include "Interfaces/ISlateRHIRendererModule.h"
#include "Interfaces/ISlateNullRendererModule.h"
#include "EngineFontServices.h"
#endif
#include "MoviePlayer.h"
#if !UE_BUILD_SHIPPING
#include "STaskGraph.h"
#include "IProfilerServiceModule.h"
#endif
#if WITH_AUTOMATION_WORKER
#include "Interfaces/IAutomationWorkerModule.h"
#endif
#endif //WITH_ENGINE
class FSlateRenderer;
class SViewport;
class IPlatformFile;
class FExternalProfiler;
class FFeedbackContext;
#if WITH_EDITOR
#include "FeedbackContextEditor.h"
static FFeedbackContextEditor UnrealEdWarn;
#include "AudioEditorModule.h"
#endif // WITH_EDITOR
#if UE_EDITOR
#include "DesktopPlatformModule.h"
#endif
#define LOCTEXT_NAMESPACE "LaunchEngineLoop"
#if PLATFORM_WINDOWS
#include "AllowWindowsPlatformTypes.h"
#include <ObjBase.h>
#include "HideWindowsPlatformTypes.h"
#endif
#if ENABLE_VISUAL_LOG
#include "VisualLogger/VisualLogger.h"
#endif
#if WITH_LAUNCHERCHECK
#include "LauncherCheck.h"
#endif
#if WITH_COREUOBJECT
#ifndef USE_LOCALIZED_PACKAGE_CACHE
#define USE_LOCALIZED_PACKAGE_CACHE 1
#endif
#else
#define USE_LOCALIZED_PACKAGE_CACHE 0
#endif
static TAutoConsoleVariable<int32> CVarDoAsyncEndOfFrameTasksRandomize(
TEXT("tick.DoAsyncEndOfFrameTasks.Randomize"),
0,
TEXT("Used to add random sleeps to tick.DoAsyncEndOfFrameTasks to shake loose bugs on either thread. Also does random render thread flushes from the game thread.")
);
static FAutoConsoleTaskPriority CPrio_AsyncEndOfFrameGameTasks(
TEXT("TaskGraph.TaskPriorities.AsyncEndOfFrameGameTasks"),
TEXT("Task and thread priority for the experiemntal async end of frame tasks."),
ENamedThreads::HighThreadPriority,
ENamedThreads::NormalTaskPriority,
ENamedThreads::HighTaskPriority
);
/** Task that executes concurrently with Slate when tick.DoAsyncEndOfFrameTasks is true. */
class FExecuteConcurrentWithSlateTickTask
{
TFunctionRef<void()> TickWithSlate;
public:
FExecuteConcurrentWithSlateTickTask(TFunctionRef<void()> InTickWithSlate)
: TickWithSlate(InTickWithSlate)
{
}
static FORCEINLINE TStatId GetStatId()
{
RETURN_QUICK_DECLARE_CYCLE_STAT(FExecuteConcurrentWithSlateTickTask, STATGROUP_TaskGraphTasks);
}
static FORCEINLINE ENamedThreads::Type GetDesiredThread()
{
return CPrio_AsyncEndOfFrameGameTasks.Get();
}
static FORCEINLINE ESubsequentsMode::Type GetSubsequentsMode() { return ESubsequentsMode::TrackSubsequents; }
void DoTask(ENamedThreads::Type CurrentThread, const FGraphEventRef& MyCompletionGraphEvent)
{
TickWithSlate();
}
};
// Pipe output to std output
// This enables UBT to collect the output for it's own use
class FOutputDeviceStdOutput : public FOutputDevice
{
public:
FOutputDeviceStdOutput()
{
bAllowLogVerbosity = FParse::Param(FCommandLine::Get(), TEXT("AllowStdOutLogVerbosity"));
}
virtual ~FOutputDeviceStdOutput()
{
}
virtual void Serialize( const TCHAR* V, ELogVerbosity::Type Verbosity, const class FName& Category ) override
{
if ( (bAllowLogVerbosity && Verbosity <= ELogVerbosity::Log) || (Verbosity <= ELogVerbosity::Display) )
{
#if PLATFORM_USE_LS_SPEC_FOR_WIDECHAR
wprintf(TEXT("\n%ls"), *FOutputDeviceHelper::FormatLogLine(Verbosity, Category, V, GPrintLogTimes));
#else
wprintf(TEXT("\n%s"), *FOutputDeviceHelper::FormatLogLine(Verbosity, Category, V, GPrintLogTimes));
#endif
fflush(stdout);
}
}
private:
bool bAllowLogVerbosity;
};
// Exits the game/editor if any of the specified phrases appears in the log output
class FOutputDeviceTestExit : public FOutputDevice
{
TArray<FString> ExitPhrases;
public:
FOutputDeviceTestExit(const TArray<FString>& InExitPhrases)
: ExitPhrases(InExitPhrases)
{
}
virtual ~FOutputDeviceTestExit()
{
}
virtual void Serialize(const TCHAR* V, ELogVerbosity::Type Verbosity, const class FName& Category) override
{
if (!GIsRequestingExit)
{
for (auto& Phrase : ExitPhrases)
{
if (FCString::Stristr(V, *Phrase) && !FCString::Stristr(V, TEXT("-testexit=")))
{
#if WITH_ENGINE
if (GEngine != nullptr)
{
if (GIsEditor)
{
GEngine->DeferredCommands.Add(TEXT("CLOSE_SLATE_MAINFRAME"));
}
else
{
GEngine->Exec(nullptr, TEXT("QUIT"));
}
}
#else
FPlatformMisc::RequestExit(true);
#endif
break;
}
}
}
}
};
static TUniquePtr<FOutputDeviceConsole> GScopedLogConsole;
static TUniquePtr<FOutputDeviceStdOutput> GScopedStdOut;
static TUniquePtr<FOutputDeviceTestExit> GScopedTestExit;
#if WITH_ENGINE
static void RHIExitAndStopRHIThread()
{
#if HAS_GPU_STATS
FRealtimeGPUProfiler::Get()->Release();
#endif
RHIExit();
// Stop the RHI Thread
if (GUseRHIThread)
{
DECLARE_CYCLE_STAT(TEXT("Wait For RHIThread Finish"), STAT_WaitForRHIThreadFinish, STATGROUP_TaskGraphTasks);
FGraphEventRef QuitTask = TGraphTask<FReturnGraphTask>::CreateTask(nullptr, ENamedThreads::GameThread).ConstructAndDispatchWhenReady(ENamedThreads::RHIThread);
FTaskGraphInterface::Get().WaitUntilTaskCompletes(QuitTask, ENamedThreads::GameThread_Local);
}
}
#endif
/**
* Initializes std out device and adds it to GLog
**/
void InitializeStdOutDevice()
{
// Check if something is trying to initialize std out device twice.
check(!GScopedStdOut);
GScopedStdOut = MakeUnique<FOutputDeviceStdOutput>();
GLog->AddOutputDevice(GScopedStdOut.Get());
}
bool ParseGameProjectFromCommandLine(const TCHAR* InCmdLine, FString& OutProjectFilePath, FString& OutGameName)
{
const TCHAR *CmdLine = InCmdLine;
FString FirstCommandLineToken = FParse::Token(CmdLine, 0);
// trim any whitespace at edges of string - this can happen if the token was quoted with leading or trailing whitespace
// VC++ tends to do this in its "external tools" config
FirstCommandLineToken = FirstCommandLineToken.Trim();
//
OutProjectFilePath = TEXT("");
OutGameName = TEXT("");
if ( FirstCommandLineToken.Len() && !FirstCommandLineToken.StartsWith(TEXT("-")) )
{
// The first command line argument could be the project file if it exists or the game name if not launching with a project file
const FString ProjectFilePath = FString(FirstCommandLineToken);
if ( FPaths::GetExtension(ProjectFilePath) == FProjectDescriptor::GetExtension() )
{
OutProjectFilePath = FirstCommandLineToken;
// Here we derive the game name from the project file
OutGameName = FPaths::GetBaseFilename(OutProjectFilePath);
return true;
}
else if (FPaths::IsRelative(FirstCommandLineToken) && FPlatformProperties::IsMonolithicBuild() == false)
{
// Full game name is assumed to be the first token
OutGameName = MoveTemp(FirstCommandLineToken);
// Derive the project path from the game name. All games must have a uproject file, even if they are in the root folder.
OutProjectFilePath = FPaths::Combine(*FPaths::RootDir(), *OutGameName, *FString(OutGameName + TEXT(".") + FProjectDescriptor::GetExtension()));
return true;
}
}
#if WITH_EDITOR
if (FEditorCommandLineUtils::ParseGameProjectPath(InCmdLine, OutProjectFilePath, OutGameName))
{
return true;
}
#endif
return false;
}
bool LaunchSetGameName(const TCHAR *InCmdLine, FString& OutGameProjectFilePathUnnormalized)
{
if (GIsGameAgnosticExe)
{
// Initialize GameName to an empty string. Populate it below.
FApp::SetGameName(TEXT(""));
FString ProjFilePath;
FString LocalGameName;
if (ParseGameProjectFromCommandLine(InCmdLine, ProjFilePath, LocalGameName) == true)
{
// Only set the game name if this is NOT a program...
if (FPlatformProperties::IsProgram() == false)
{
FApp::SetGameName(*LocalGameName);
}
OutGameProjectFilePathUnnormalized = ProjFilePath;
FPaths::SetProjectFilePath(ProjFilePath);
}
#if UE_GAME
else
{
// Try to use the executable name as the game name.
LocalGameName = FPlatformProcess::ExecutableName();
int32 FirstCharToRemove = INDEX_NONE;
if (LocalGameName.FindChar(TCHAR('-'), FirstCharToRemove))
{
LocalGameName = LocalGameName.Left(FirstCharToRemove);
}
FApp::SetGameName(*LocalGameName);
// Check it's not UE4Game, otherwise assume a uproject file relative to the game project directory
if (LocalGameName != TEXT("UE4Game"))
{
ProjFilePath = FPaths::Combine(TEXT(".."), TEXT(".."), TEXT(".."), *LocalGameName, *FString(LocalGameName + TEXT(".") + FProjectDescriptor::GetExtension()));
OutGameProjectFilePathUnnormalized = ProjFilePath;
FPaths::SetProjectFilePath(ProjFilePath);
}
}
#endif
static bool bPrinted = false;
if (!bPrinted)
{
bPrinted = true;
if (FApp::HasGameName())
{
UE_LOG(LogInit, Display, TEXT("Running engine for game: %s"), FApp::GetGameName());
}
else
{
if (FPlatformProperties::RequiresCookedData())
{
UE_LOG(LogInit, Fatal, TEXT("Non-agnostic games on cooked platforms require a uproject file be specified."));
}
else
{
UE_LOG(LogInit, Display, TEXT("Running engine without a game"));
}
}
}
}
else
{
FString ProjFilePath;
FString LocalGameName;
if (ParseGameProjectFromCommandLine(InCmdLine, ProjFilePath, LocalGameName) == true)
{
if (FPlatformProperties::RequiresCookedData())
{
// Non-agnostic exes that require cooked data cannot load projects, so make sure that the LocalGameName is the GameName
if (LocalGameName != FApp::GetGameName())
{
UE_LOG(LogInit, Fatal, TEXT("Non-agnostic games cannot load projects on cooked platforms - try running UE4Game."));
}
}
// Only set the game name if this is NOT a program...
if (FPlatformProperties::IsProgram() == false)
{
FApp::SetGameName(*LocalGameName);
}
OutGameProjectFilePathUnnormalized = ProjFilePath;
FPaths::SetProjectFilePath(ProjFilePath);
}
// In a non-game agnostic exe, the game name should already be assigned by now.
if (!FApp::HasGameName())
{
UE_LOG(LogInit, Fatal,TEXT("Could not set game name!"));
}
}
return true;
}
void LaunchFixGameNameCase()
{
#if PLATFORM_DESKTOP && !IS_PROGRAM
// This is to make sure this function is not misused and is only called when the game name is set
check(FApp::HasGameName());
// correct the case of the game name, if possible (unless we're running a program and the game name is already set)
if (FPaths::IsProjectFilePathSet())
{
const FString GameName(FPaths::GetBaseFilename(IFileManager::Get().GetFilenameOnDisk(*FPaths::GetProjectFilePath())));
const bool bGameNameMatchesProjectCaseSensitive = (FCString::Strcmp(*GameName, FApp::GetGameName()) == 0);
if (!bGameNameMatchesProjectCaseSensitive && (FApp::IsGameNameEmpty() || GIsGameAgnosticExe || (GameName.Len() > 0 && GIsGameAgnosticExe)))
{
if (GameName == FApp::GetGameName()) // case insensitive compare
{
FApp::SetGameName(*GameName);
}
else
{
const FText Message = FText::Format(
NSLOCTEXT("Core", "MismatchedGameNames", "The name of the .uproject file ('{0}') must match the name of the project passed in the command line ('{1}')."),
FText::FromString(*GameName),
FText::FromString(FApp::GetGameName()));
if (!GIsBuildMachine)
{
UE_LOG(LogInit, Warning, TEXT("%s"), *Message.ToString());
FMessageDialog::Open(EAppMsgType::Ok, Message);
}
FApp::SetGameName(TEXT("")); // this disables part of the crash reporter to avoid writing log files to a bogus directory
if (!GIsBuildMachine)
{
exit(1);
}
UE_LOG(LogInit, Fatal, TEXT("%s"), *Message.ToString());
}
}
}
#endif //PLATFORM_DESKTOP
}
static IPlatformFile* ConditionallyCreateFileWrapper(const TCHAR* Name, IPlatformFile* CurrentPlatformFile, const TCHAR* CommandLine, bool* OutFailedToInitialize = nullptr, bool* bOutShouldBeUsed = nullptr )
{
if (OutFailedToInitialize)
{
*OutFailedToInitialize = false;
}
if ( bOutShouldBeUsed )
{
*bOutShouldBeUsed = false;
}
IPlatformFile* WrapperFile = FPlatformFileManager::Get().GetPlatformFile(Name);
if (WrapperFile != nullptr && WrapperFile->ShouldBeUsed(CurrentPlatformFile, CommandLine))
{
if ( bOutShouldBeUsed )
{
*bOutShouldBeUsed = true;
}
if (WrapperFile->Initialize(CurrentPlatformFile, CommandLine) == false)
{
if (OutFailedToInitialize)
{
*OutFailedToInitialize = true;
}
// Don't delete the platform file. It will be automatically deleted by its module.
WrapperFile = nullptr;
}
}
else
{
// Make sure it won't be used.
WrapperFile = nullptr;
}
return WrapperFile;
}
/**
* Look for any file overrides on the command line (i.e. network connection file handler)
*/
bool LaunchCheckForFileOverride(const TCHAR* CmdLine, bool& OutFileOverrideFound)
{
OutFileOverrideFound = false;
// Get the physical platform file.
IPlatformFile* CurrentPlatformFile = &FPlatformFileManager::Get().GetPlatformFile();
// Try to create pak file wrapper
{
IPlatformFile* PlatformFile = ConditionallyCreateFileWrapper(TEXT("PakFile"), CurrentPlatformFile, CmdLine);
if (PlatformFile)
{
CurrentPlatformFile = PlatformFile;
FPlatformFileManager::Get().SetPlatformFile(*CurrentPlatformFile);
}
PlatformFile = ConditionallyCreateFileWrapper(TEXT("CachedReadFile"), CurrentPlatformFile, CmdLine);
if (PlatformFile)
{
CurrentPlatformFile = PlatformFile;
FPlatformFileManager::Get().SetPlatformFile(*CurrentPlatformFile);
}
}
// Try to create sandbox wrapper
{
IPlatformFile* PlatformFile = ConditionallyCreateFileWrapper(TEXT("SandboxFile"), CurrentPlatformFile, CmdLine);
if (PlatformFile)
{
CurrentPlatformFile = PlatformFile;
FPlatformFileManager::Get().SetPlatformFile(*CurrentPlatformFile);
}
}
#if !UE_BUILD_SHIPPING // UFS clients are not available in shipping builds.
// Streaming network wrapper (it has a priority over normal network wrapper)
bool bNetworkFailedToInitialize = false;
do
{
bool bShouldUseStreamingFile = false;
IPlatformFile* NetworkPlatformFile = ConditionallyCreateFileWrapper(TEXT("StreamingFile"), CurrentPlatformFile, CmdLine, &bNetworkFailedToInitialize, &bShouldUseStreamingFile);
if (NetworkPlatformFile)
{
CurrentPlatformFile = NetworkPlatformFile;
FPlatformFileManager::Get().SetPlatformFile(*CurrentPlatformFile);
}
// if streaming network platform file was tried this loop don't try this one
// Network file wrapper (only create if the streaming wrapper hasn't been created)
if ( !bShouldUseStreamingFile && !NetworkPlatformFile)
{
NetworkPlatformFile = ConditionallyCreateFileWrapper(TEXT("NetworkFile"), CurrentPlatformFile, CmdLine, &bNetworkFailedToInitialize);
if (NetworkPlatformFile)
{
CurrentPlatformFile = NetworkPlatformFile;
FPlatformFileManager::Get().SetPlatformFile(*CurrentPlatformFile);
}
}
if (bNetworkFailedToInitialize)
{
FString HostIpString;
FParse::Value(CmdLine, TEXT("-FileHostIP="), HostIpString);
#if PLATFORM_REQUIRES_FILESERVER
FPlatformMisc::LowLevelOutputDebugStringf(TEXT("Failed to connect to file server at %s. RETRYING in 5s.\n"), *HostIpString);
FPlatformProcess::Sleep(5.0f);
uint32 Result = 2;
#else //PLATFORM_REQUIRES_FILESERVER
// note that this can't be localized because it happens before we connect to a filserver - localizing would cause ICU to try to load.... from over the file server connection!
FString Error = FString::Printf(TEXT("Failed to connect to any of the following file servers:\n\n %s\n\nWould you like to try again? No will fallback to local disk files, Cancel will quit."), *HostIpString.Replace( TEXT("+"), TEXT("\n ")));
uint32 Result = FMessageDialog::Open( EAppMsgType::YesNoCancel, FText::FromString( Error ) );
#endif //PLATFORM_REQUIRES_FILESERVER
if (Result == EAppReturnType::No)
{
break;
}
else if (Result == EAppReturnType::Cancel)
{
// Cancel - return a failure, and quit
return false;
}
}
}
while (bNetworkFailedToInitialize);
#endif
#if !UE_BUILD_SHIPPING
// Try to create file profiling wrapper
{
IPlatformFile* PlatformFile = ConditionallyCreateFileWrapper(TEXT("ProfileFile"), CurrentPlatformFile, CmdLine);
if (PlatformFile)
{
CurrentPlatformFile = PlatformFile;
FPlatformFileManager::Get().SetPlatformFile(*CurrentPlatformFile);
}
}
{
IPlatformFile* PlatformFile = ConditionallyCreateFileWrapper(TEXT("SimpleProfileFile"), CurrentPlatformFile, CmdLine);
if (PlatformFile)
{
CurrentPlatformFile = PlatformFile;
FPlatformFileManager::Get().SetPlatformFile(*CurrentPlatformFile);
}
}
// Try and create file timings stats wrapper
{
IPlatformFile* PlatformFile = ConditionallyCreateFileWrapper(TEXT("FileReadStats"), CurrentPlatformFile, CmdLine);
if (PlatformFile)
{
CurrentPlatformFile = PlatformFile;
FPlatformFileManager::Get().SetPlatformFile(*CurrentPlatformFile);
}
}
// Try and create file open log wrapper (lists the order files are first opened)
{
IPlatformFile* PlatformFile = ConditionallyCreateFileWrapper(TEXT("FileOpenLog"), CurrentPlatformFile, CmdLine);
if (PlatformFile)
{
CurrentPlatformFile = PlatformFile;
FPlatformFileManager::Get().SetPlatformFile(*CurrentPlatformFile);
}
}
#endif //#if !UE_BUILD_SHIPPING
// Wrap the above in a file logging singleton if requested
{
IPlatformFile* PlatformFile = ConditionallyCreateFileWrapper(TEXT("LogFile"), CurrentPlatformFile, CmdLine);
if (PlatformFile)
{
CurrentPlatformFile = PlatformFile;
FPlatformFileManager::Get().SetPlatformFile(*CurrentPlatformFile);
}
}
// If our platform file is different than it was when we started, then an override was used
OutFileOverrideFound = (CurrentPlatformFile != &FPlatformFileManager::Get().GetPlatformFile());
return true;
}
bool LaunchHasIncompleteGameName()
{
if ( FApp::HasGameName() && !FPaths::IsProjectFilePathSet() )
{
// Verify this is a legitimate game name
// Launched with a game name. See if the <GameName> folder exists. If it doesn't, it could instead be <GameName>Game
const FString NonSuffixedGameFolder = FPaths::RootDir() / FApp::GetGameName();
if (FPlatformFileManager::Get().GetPlatformFile().DirectoryExists(*NonSuffixedGameFolder) == false)
{
const FString SuffixedGameFolder = NonSuffixedGameFolder + TEXT("Game");
if (FPlatformFileManager::Get().GetPlatformFile().DirectoryExists(*SuffixedGameFolder))
{
return true;
}
}
}
return false;
}
void LaunchUpdateMostRecentProjectFile()
{
// If we are launching without a game name or project file, we should use the last used project file, if it exists
const FString& AutoLoadProjectFileName = IProjectManager::Get().GetAutoLoadProjectFileName();
FString RecentProjectFileContents;
if ( FFileHelper::LoadFileToString(RecentProjectFileContents, *AutoLoadProjectFileName) )
{
if ( RecentProjectFileContents.Len() )
{
const FString AutoLoadInProgressFilename = AutoLoadProjectFileName + TEXT(".InProgress");
if ( FPlatformFileManager::Get().GetPlatformFile().FileExists(*AutoLoadInProgressFilename) )
{
// We attempted to auto-load a project but the last run did not make it to UEditorEngine::InitEditor.
// This indicates that there was a problem loading the project.
// Do not auto-load the project, instead load normally until the next time the editor starts successfully.
UE_LOG(LogInit, Display, TEXT("There was a problem auto-loading %s. Auto-load will be disabled until the editor successfully starts up with a project."), *RecentProjectFileContents);
}
else if ( FPlatformFileManager::Get().GetPlatformFile().FileExists(*RecentProjectFileContents) )
{
// The previously loaded project file was found. Change the game name here and update the project file path
FApp::SetGameName(*FPaths::GetBaseFilename(RecentProjectFileContents));
FPaths::SetProjectFilePath(RecentProjectFileContents);
UE_LOG(LogInit, Display, TEXT("Loading recent project file: %s"), *RecentProjectFileContents);
// Write a file indicating that we are trying to auto-load a project.
// This file prevents auto-loading of projects for as long as it exists. It is a detection system for failed auto-loads.
// The file is deleted in UEditorEngine::InitEditor, thus if the load does not make it that far then the project will not be loaded again.
FFileHelper::SaveStringToFile(TEXT(""), *AutoLoadInProgressFilename);
}
}
}
}
/*-----------------------------------------------------------------------------
FEngineLoop implementation.
-----------------------------------------------------------------------------*/
FEngineLoop::FEngineLoop()
#if WITH_ENGINE
: EngineService(nullptr)
#endif
{ }
int32 FEngineLoop::PreInit(int32 ArgC, TCHAR* ArgV[], const TCHAR* AdditionalCommandline)
{
FMemory::SetupTLSCachesOnCurrentThread();
FString CmdLine;
// loop over the parameters, skipping the first one (which is the executable name)
for (int32 Arg = 1; Arg < ArgC; Arg++)
{
FString ThisArg = ArgV[Arg];
if (ThisArg.Contains(TEXT(" ")) && !ThisArg.Contains(TEXT("\"")))
{
int32 EqualsAt = ThisArg.Find(TEXT("="));
if (EqualsAt > 0 && ThisArg.Find(TEXT(" ")) > EqualsAt)
{
ThisArg = ThisArg.Left(EqualsAt + 1) + FString("\"") + ThisArg.RightChop(EqualsAt + 1) + FString("\"");
}
else
{
ThisArg = FString("\"") + ThisArg + FString("\"");
}
}
CmdLine += ThisArg;
// put a space between each argument (not needed after the end)
if (Arg + 1 < ArgC)
{
CmdLine += TEXT(" ");
}
}
// append the additional extra command line
if (AdditionalCommandline)
{
CmdLine += TEXT(" ");
CmdLine += AdditionalCommandline;
}
// send the command line without the exe name
return GEngineLoop.PreInit(*CmdLine);
}
#if WITH_ENGINE
bool IsServerDelegateForOSS(FName WorldContextHandle)
{
if (IsRunningDedicatedServer())
{
return true;
}
UWorld* World = nullptr;
#if WITH_EDITOR
if (WorldContextHandle != NAME_None)
{
FWorldContext& WorldContext = GEngine->GetWorldContextFromHandleChecked(WorldContextHandle);
check(WorldContext.WorldType == EWorldType::Game || WorldContext.WorldType == EWorldType::PIE);
World = WorldContext.World();
}
else
#endif
{
ensure(WorldContextHandle == NAME_None);
UGameEngine* GameEngine = Cast<UGameEngine>(GEngine);
if (GameEngine)
{
World = GameEngine->GetGameWorld();
}
else
{
UE_LOG(LogInit, Error, TEXT("Failed to determine if OSS is server in PIE, OSS requests will fail"));
return false;
}
}
ENetMode NetMode = World ? World->GetNetMode() : NM_Standalone;
return (NetMode == NM_ListenServer || NetMode == NM_DedicatedServer);
}
#endif
DECLARE_CYCLE_STAT( TEXT( "FEngineLoop::PreInit.AfterStats" ), STAT_FEngineLoop_PreInit_AfterStats, STATGROUP_LoadTime );
int32 FEngineLoop::PreInit( const TCHAR* CmdLine )
{
if (FParse::Param(CmdLine, TEXT("UTF8Output")))
{
FPlatformMisc::SetUTF8Output();
}
// Switch into executable's directory.
FPlatformProcess::SetCurrentWorkingDirectoryToBaseDir();
// this is set later with shorter command lines, but we want to make sure it is set ASAP as some subsystems will do the tests themselves...
// also realize that command lines can be pulled from the network at a slightly later time.
if (!FCommandLine::Set(CmdLine))
{
// Fail, shipping builds will crash if setting command line fails
return -1;
}
#if WITH_LAUNCHERCHECK
if (ILauncherCheckModule::Get().WasRanFromLauncher() == false)
{
// Tell Launcher to run us instead
ILauncherCheckModule::Get().RunLauncher(ELauncherAction::AppLaunch);
// We wish to exit
GIsRequestingExit = true;
return 0;
}
#endif
#if STATS
// Create the stats malloc profiler proxy.
if( FStatsMallocProfilerProxy::HasMemoryProfilerToken() )
{
if (PLATFORM_USES_FIXED_GMalloc_CLASS)
{
UE_LOG(LogMemory, Fatal, TEXT("Cannot do malloc profiling with PLATFORM_USES_FIXED_GMalloc_CLASS."));
}
// Assumes no concurrency here.
GMalloc = FStatsMallocProfilerProxy::Get();
}
#endif // STATS
// Name of project file before normalization (as specified in command line).
// Used to fixup project name if necessary.
FString GameProjectFilePathUnnormalized;
// Set GameName, based on the command line
if (LaunchSetGameName(CmdLine, GameProjectFilePathUnnormalized) == false)
{
// If it failed, do not continue
return 1;
}
// Initialize log console here to avoid statics initialization issues when launched from the command line.
GScopedLogConsole = TUniquePtr<FOutputDeviceConsole>(FPlatformOutputDevices::GetLogConsole());
// Always enable the backlog so we get all messages, we will disable and clear it in the game
// as soon as we determine whether GIsEditor == false
GLog->EnableBacklog(true);
// Initialize std out device as early as possible if requested in the command line
if (FParse::Param(FCommandLine::Get(), TEXT("stdout")))
{
InitializeStdOutDevice();
}
#if !UE_BUILD_SHIPPING
if (FPlatformProperties::SupportsQuit())
{
FString ExitPhrases;
if (FParse::Value(FCommandLine::Get(), TEXT("testexit="), ExitPhrases))
{
TArray<FString> ExitPhrasesList;
if (ExitPhrases.ParseIntoArray(ExitPhrasesList, TEXT("+"), true) > 0)
{
GScopedTestExit = MakeUnique<FOutputDeviceTestExit>(ExitPhrasesList);
GLog->AddOutputDevice(GScopedTestExit.Get());
}
}
}
if (FParse::Param(FCommandLine::Get(), TEXT("emitdrawevents")))
{
GEmitDrawEvents = true;
}
#endif // !UE_BUILD_SHIPPING
// Switch into executable's directory (may be required by some of the platform file overrides)
FPlatformProcess::SetCurrentWorkingDirectoryToBaseDir();
// This fixes up the relative project path, needs to happen before we set platform file paths
if (FPlatformProperties::IsProgram() == false)
{
if (FPaths::IsProjectFilePathSet())
{
FString ProjPath = FPaths::GetProjectFilePath();
if (FPaths::FileExists(ProjPath) == false)
{
// display it multiple ways, it's very important error message...
FPlatformMisc::LowLevelOutputDebugStringf(TEXT("Project file not found: %s"), *ProjPath);
UE_LOG(LogInit, Display, TEXT("Project file not found: %s"), *ProjPath);
UE_LOG(LogInit, Display, TEXT("\tAttempting to find via project info helper."));
// Use the uprojectdirs
FString GameProjectFile = FUProjectDictionary::GetDefault().GetRelativeProjectPathForGame(FApp::GetGameName(), FPlatformProcess::BaseDir());
if (GameProjectFile.IsEmpty() == false)
{
UE_LOG(LogInit, Display, TEXT("\tFound project file %s."), *GameProjectFile);
FPaths::SetProjectFilePath(GameProjectFile);
// Fixup command line if project file wasn't found in specified directory to properly parse next arguments.
FString OldCommandLine = FString(FCommandLine::Get());
OldCommandLine.ReplaceInline(*GameProjectFilePathUnnormalized, *GameProjectFile, ESearchCase::CaseSensitive);
FCommandLine::Set(*OldCommandLine);
CmdLine = FCommandLine::Get();
}
}
}
}
// allow the command line to override the platform file singleton
bool bFileOverrideFound = false;
if (LaunchCheckForFileOverride(CmdLine, bFileOverrideFound) == false)
{
// if it failed, we cannot continue
return 1;
}
// Initialize file manager
IFileManager::Get().ProcessCommandLineOptions();
if( GIsGameAgnosticExe )
{
// If we launched without a project file, but with a game name that is incomplete, warn about the improper use of a Game suffix
if ( LaunchHasIncompleteGameName() )
{
// We did not find a non-suffixed folder and we DID find the suffixed one.
// The engine MUST be launched with <GameName>Game.
const FText GameNameText = FText::FromString(FApp::GetGameName());
FMessageDialog::Open(EAppMsgType::Ok, FText::Format( LOCTEXT("RequiresGamePrefix", "Error: UE4Editor does not append 'Game' to the passed in game name.\nYou must use the full name.\nYou specified '{0}', use '{0}Game'."), GameNameText ) );
return 1;
}
}
// remember thread id of the main thread
GGameThreadId = FPlatformTLS::GetCurrentThreadId();
GIsGameThreadIdInitialized = true;
FPlatformProcess::SetThreadAffinityMask(FPlatformAffinity::GetMainGameMask());
FPlatformProcess::SetupGameThread();
// Figure out whether we're the editor, ucc or the game.
const SIZE_T CommandLineSize = FCString::Strlen(CmdLine)+1;
TCHAR* CommandLineCopy = new TCHAR[ CommandLineSize ];
FCString::Strcpy( CommandLineCopy, CommandLineSize, CmdLine );
const TCHAR* ParsedCmdLine = CommandLineCopy;
FString Token = FParse::Token( ParsedCmdLine, 0);
#if WITH_ENGINE
TArray<FString> Tokens;
TArray<FString> Switches;
UCommandlet::ParseCommandLine(CommandLineCopy, Tokens, Switches);
bool bHasCommandletToken = false;
for( int32 TokenIndex = 0; TokenIndex < Tokens.Num(); ++TokenIndex )
{
if( Tokens[TokenIndex].EndsWith(TEXT("Commandlet")) )
{
bHasCommandletToken = true;
Token = Tokens[TokenIndex];
break;
}
}
for( int32 SwitchIndex = 0; SwitchIndex < Switches.Num() && !bHasCommandletToken; ++SwitchIndex )
{
if( Switches[SwitchIndex].StartsWith(TEXT("RUN=")) )
{
bHasCommandletToken = true;
Token = Switches[SwitchIndex];
break;
}
}
if (bHasCommandletToken)
{
// will be reset later once the commandlet class loaded
PRIVATE_GIsRunningCommandlet = true;
}
#endif // WITH_ENGINE
// trim any whitespace at edges of string - this can happen if the token was quoted with leading or trailing whitespace
// VC++ tends to do this in its "external tools" config
Token = Token.Trim();
// Path returned by FPaths::GetProjectFilePath() is normalized, so may have symlinks and ~ resolved and may differ from the original path to .uproject passed in the command line
FString NormalizedToken = Token;
FPaths::NormalizeFilename(NormalizedToken);
const bool bFirstTokenIsGameName = (FApp::HasGameName() && Token == FApp::GetGameName());
const bool bFirstTokenIsGameProjectFilePath = (FPaths::IsProjectFilePathSet() && NormalizedToken == FPaths::GetProjectFilePath());
const bool bFirstTokenIsGameProjectFileShortName = (FPaths::IsProjectFilePathSet() && Token == FPaths::GetCleanFilename(FPaths::GetProjectFilePath()));
if (bFirstTokenIsGameName || bFirstTokenIsGameProjectFilePath || bFirstTokenIsGameProjectFileShortName)
{
// first item on command line was the game name, remove it in all cases
FString RemainingCommandline = ParsedCmdLine;
FCString::Strcpy( CommandLineCopy, CommandLineSize, *RemainingCommandline );
ParsedCmdLine = CommandLineCopy;
// Set a new command-line that doesn't include the game name as the first argument
FCommandLine::Set(ParsedCmdLine);
Token = FParse::Token( ParsedCmdLine, 0);
Token = Token.Trim();
// if the next token is a project file, then we skip it (which can happen on some platforms that combine
// commandlines... this handles extra .uprojects, but if you run with MyGame MyGame, we can't tell if
// the second MyGame is a map or not)
while (FPaths::GetExtension(Token) == FProjectDescriptor::GetExtension())
{
Token = FParse::Token(ParsedCmdLine, 0);
Token = Token.Trim();
}
if (bFirstTokenIsGameProjectFilePath || bFirstTokenIsGameProjectFileShortName)
{
// Convert it to relative if possible...
FString RelativeGameProjectFilePath = FFileManagerGeneric::DefaultConvertToRelativePath(*FPaths::GetProjectFilePath());
if (RelativeGameProjectFilePath != FPaths::GetProjectFilePath())
{
FPaths::SetProjectFilePath(RelativeGameProjectFilePath);
}
}
}
// look early for the editor token
bool bHasEditorToken = false;
#if UE_EDITOR
// Check each token for '-game', '-server' or '-run='
bool bIsNotEditor = false;
// This isn't necessarily pretty, but many requests have been made to allow
// UE4Editor.exe <GAMENAME> -game <map>
// or
// UE4Editor.exe <GAMENAME> -game 127.0.0.0
// We don't want to remove the -game from the commandline just yet in case
// we need it for something later. So, just move it to the end for now...
const bool bFirstTokenIsGame = (Token == TEXT("-GAME"));
const bool bFirstTokenIsServer = (Token == TEXT("-SERVER"));
const bool bFirstTokenIsModeOverride = bFirstTokenIsGame || bFirstTokenIsServer || bHasCommandletToken;
const TCHAR* CommandletCommandLine = nullptr;
if (bFirstTokenIsModeOverride)
{
bIsNotEditor = true;
if (bFirstTokenIsGame || bFirstTokenIsServer)
{
// Move the token to the end of the list...
FString RemainingCommandline = ParsedCmdLine;
RemainingCommandline = RemainingCommandline.Trim();
RemainingCommandline += FString::Printf(TEXT(" %s"), *Token);
FCommandLine::Set(*RemainingCommandline);
}
if (bHasCommandletToken)
{
#if STATS
// Leave the stats enabled.
if (!FStats::EnabledForCommandlet())
{
FThreadStats::MasterDisableForever();
}
#endif
if (Token.StartsWith(TEXT("run=")))
{
Token = Token.RightChop(4);
if (!Token.EndsWith(TEXT("Commandlet")))
{
Token += TEXT("Commandlet");
}
}
CommandletCommandLine = ParsedCmdLine;
}
}
if (bHasCommandletToken)
{
// will be reset later once the commandlet class loaded
PRIVATE_GIsRunningCommandlet = true;
}
if( !bIsNotEditor && GIsGameAgnosticExe )
{
// If we launched without a game name or project name, try to load the most recently loaded project file.
// We can not do this if we are using a FilePlatform override since the game directory may already be established.
const bool bIsBuildMachine = FParse::Param(FCommandLine::Get(), TEXT("BUILDMACHINE"));
const bool bLoadMostRecentProjectFileIfItExists = !FApp::HasGameName() && !bFileOverrideFound && !bIsBuildMachine && !FParse::Param( CmdLine, TEXT("norecentproject") );
if (bLoadMostRecentProjectFileIfItExists )
{
LaunchUpdateMostRecentProjectFile();
}
}
FString CheckToken = Token;
bool bFoundValidToken = false;
while (!bFoundValidToken && (CheckToken.Len() > 0))
{
if (!bIsNotEditor)
{
bool bHasNonEditorToken = (CheckToken == TEXT("-GAME")) || (CheckToken == TEXT("-SERVER")) || (CheckToken.StartsWith(TEXT("RUN="))) || CheckToken.EndsWith(TEXT("Commandlet"));
if (bHasNonEditorToken)
{
bIsNotEditor = true;
bFoundValidToken = true;
}
}
CheckToken = FParse::Token(ParsedCmdLine, 0);
}
bHasEditorToken = !bIsNotEditor;
#elif WITH_ENGINE
const TCHAR* CommandletCommandLine = nullptr;
if (bHasCommandletToken)
{
#if STATS
// Leave the stats enabled.
if (!FStats::EnabledForCommandlet())
{
FThreadStats::MasterDisableForever();
}
#endif
if (Token.StartsWith(TEXT("run=")))
{
Token = Token.RightChop(4);
if (!Token.EndsWith(TEXT("Commandlet")))
{
Token += TEXT("Commandlet");
}
}
CommandletCommandLine = ParsedCmdLine;
}
#if WITH_EDITOR && WITH_EDITORONLY_DATA
// If a non-editor target build w/ WITH_EDITOR and WITH_EDITORONLY_DATA, use the old token check...
//@todo. Is this something we need to support?
bHasEditorToken = Token == TEXT("EDITOR");
#else
// Game, server and commandlets never set the editor token
bHasEditorToken = false;
#endif
#endif //UE_EDITOR
#if !UE_BUILD_SHIPPING
// Benchmarking.
FApp::SetBenchmarking(FParse::Param(FCommandLine::Get(),TEXT("BENCHMARK")));
#else
FApp::SetBenchmarking(false);
#endif // !UE_BUILD_SHIPPING
// "-Deterministic" is a shortcut for "-UseFixedTimeStep -FixedSeed"
bool bDeterministic = FParse::Param(FCommandLine::Get(), TEXT("Deterministic"));
FApp::SetUseFixedTimeStep(bDeterministic || FParse::Param(FCommandLine::Get(), TEXT("UseFixedTimeStep")));
FApp::bUseFixedSeed = bDeterministic || FApp::IsBenchmarking() || FParse::Param(FCommandLine::Get(),TEXT("FixedSeed"));
// Initialize random number generator.
{
uint32 Seed1 = 0;
uint32 Seed2 = 0;
if(!FApp::bUseFixedSeed)
{
Seed1 = FPlatformTime::Cycles();
Seed2 = FPlatformTime::Cycles();
}
FMath::RandInit(Seed1);
FMath::SRandInit(Seed2);
UE_LOG(LogInit, Display, TEXT("RandInit(%d) SRandInit(%d)."), Seed1, Seed2);
}
// Set up the module list and version information, if it's not compiled-in
#if !IS_MONOLITHIC && BUILT_FROM_CHANGELIST == 0
static FVersionedModuleEnumerator ModuleEnumerator;
if(ModuleEnumerator.RegisterWithModuleManager())
{
const FVersionManifest& Manifest = ModuleEnumerator.GetInitialManifest();
if(Manifest.Changelist != 0 && !FEngineVersion::OverrideCurrentVersionChangelist(Manifest.Changelist, Manifest.CompatibleChangelist))
{
UE_LOG(LogInit, Fatal, TEXT("Couldn't update engine changelist to %d."), Manifest.Changelist);
}
UE_LOG(LogInit, Log, TEXT("Using version manifest at CL %d with build ID '%s'"), Manifest.Changelist, *Manifest.BuildId);
}
#endif
#if !IS_PROGRAM
if ( !GIsGameAgnosticExe && FApp::HasGameName() && !FPaths::IsProjectFilePathSet() )
{
// If we are using a non-agnostic exe where a name was specified but we did not specify a project path. Assemble one based on the game name.
const FString ProjectFilePath = FPaths::Combine(*FPaths::GameDir(), *FString::Printf(TEXT("%s.%s"), FApp::GetGameName(), *FProjectDescriptor::GetExtension()));
FPaths::SetProjectFilePath(ProjectFilePath);
}
#endif
// Now verify the project file if we have one
if (FPaths::IsProjectFilePathSet()
#if IS_PROGRAM
// Programs don't need uproject files to exist, but some do specify them and if they exist we should load them
&& FPaths::FileExists(FPaths::GetProjectFilePath())
#endif
)
{
if (!IProjectManager::Get().LoadProjectFile(FPaths::GetProjectFilePath()))
{
// The project file was invalid or saved with a newer version of the engine. Exit.
UE_LOG(LogInit, Warning, TEXT("Could not find a valid project file, the engine will exit now."));
return 1;
}
}
#if !IS_PROGRAM
if( FApp::HasGameName() )
{
// Tell the module manager what the game binaries folder is
const FString GameBinariesDirectory = FPaths::Combine( FPlatformMisc::GameDir(), TEXT( "Binaries" ), FPlatformProcess::GetBinariesSubdirectory() );
FModuleManager::Get().SetGameBinariesDirectory(*GameBinariesDirectory);
LaunchFixGameNameCase();
}
#endif
// initialize task graph sub-system with potential multiple threads
FTaskGraphInterface::Startup( FPlatformMisc::NumberOfCores() );
FTaskGraphInterface::Get().AttachToThread( ENamedThreads::GameThread );
#if STATS
FThreadStats::StartThread();
#endif
FScopeCycleCounter CycleCount_AfterStats( GET_STATID( STAT_FEngineLoop_PreInit_AfterStats ) );
// Load Core modules required for everything else to work (needs to be loaded before InitializeRenderingCVarsCaching)
if (!LoadCoreModules())
{
UE_LOG(LogInit, Error, TEXT("Failed to load Core modules."));
return 1;
}
#if WITH_ENGINE
extern ENGINE_API void InitializeRenderingCVarsCaching();
InitializeRenderingCVarsCaching();
#endif
bool bTokenDoesNotHaveDash = Token.Len() && FCString::Strnicmp(*Token, TEXT("-"), 1) != 0;
#if WITH_EDITOR
// If we're running as an game but don't have a project, inform the user and exit.
if (bHasEditorToken == false && bHasCommandletToken == false)
{
if ( !FPaths::IsProjectFilePathSet() )
{
//@todo this is too early to localize
FMessageDialog::Open(EAppMsgType::Ok, NSLOCTEXT("Engine", "UE4RequiresProjectFiles", "UE4 games require a project file as the first parameter."));
return 1;
}
}
if (GIsUCCMakeStandaloneHeaderGenerator)
{
// Rebuilding script requires some hacks in the engine so we flag that.
PRIVATE_GIsRunningCommandlet = true;
}
#endif //WITH_EDITOR
if (FPlatformProcess::SupportsMultithreading())
{
{
GThreadPool = FQueuedThreadPool::Allocate();
int32 NumThreadsInThreadPool = FPlatformMisc::NumberOfWorkerThreadsToSpawn();
// we are only going to give dedicated servers one pool thread
if (FPlatformProperties::IsServerOnly())
{
NumThreadsInThreadPool = 1;
}
verify(GThreadPool->Create(NumThreadsInThreadPool, 128 * 1024));
}
#if WITH_EDITOR
// when we are in the editor we like to do things like build lighting and such
// this thread pool can be used for those purposes
GLargeThreadPool = FQueuedThreadPool::Allocate();
int32 NumThreadsInLargeThreadPool = FMath::Max(FPlatformMisc::NumberOfCoresIncludingHyperthreads() - 2, 2);
verify(GLargeThreadPool->Create(NumThreadsInLargeThreadPool, 128 * 1024));
#endif
}
// Get a pointer to the log output device
GLogConsole = GScopedLogConsole.Get();
LoadPreInitModules();
// Start the application
if(!AppInit())
{
return 1;
}
#if WITH_COREUOBJECT
GNewAsyncIO = IsEventDrivenLoaderEnabled();
FPlatformFileManager::Get().InitializeNewAsyncIO();
#endif
if (FPlatformProcess::SupportsMultithreading())
{
if (GNewAsyncIO)
{
GIOThreadPool = FQueuedThreadPool::Allocate();
int32 NumThreadsInThreadPool = FPlatformMisc::NumberOfIOWorkerThreadsToSpawn();
if (FPlatformProperties::IsServerOnly())
{
NumThreadsInThreadPool = 2;
}
verify(GIOThreadPool->Create(NumThreadsInThreadPool, 16 * 1024, TPri_AboveNormal));
}
}
#if WITH_ENGINE
// Initialize system settings before anyone tries to use it...
GSystemSettings.Initialize( bHasEditorToken );
// Apply renderer settings from console variables stored in the INI.
ApplyCVarSettingsFromIni(TEXT("/Script/Engine.RendererSettings"),*GEngineIni, ECVF_SetByProjectSetting);
ApplyCVarSettingsFromIni(TEXT("/Script/Engine.RendererOverrideSettings"), *GEngineIni, ECVF_SetByProjectSetting);
ApplyCVarSettingsFromIni(TEXT("/Script/Engine.StreamingSettings"), *GEngineIni, ECVF_SetByProjectSetting);
ApplyCVarSettingsFromIni(TEXT("/Script/Engine.GarbageCollectionSettings"), *GEngineIni, ECVF_SetByProjectSetting);
ApplyCVarSettingsFromIni(TEXT("/Script/Engine.NetworkSettings"), *GEngineIni, ECVF_SetByProjectSetting);
#if !UE_SERVER
if (!IsRunningDedicatedServer())
{
if (!IsRunningCommandlet())
{
// Note: It is critical that resolution settings are loaded before the movie starts playing so that the window size and fullscreen state is known
UGameUserSettings::PreloadResolutionSettings();
}
}
#endif
// As early as possible to avoid expensive re-init of subsystems,
// after SystemSettings.ini file loading so we get the right state,
// before ConsoleVariables.ini so the local developer can always override.
// before InitializeCVarsForActiveDeviceProfile() so the platform can override user settings
Scalability::LoadState((bHasEditorToken && !GEditorSettingsIni.IsEmpty()) ? GEditorSettingsIni : GGameUserSettingsIni);
// Set all CVars which have been setup in the device profiles.
UDeviceProfileManager::InitializeCVarsForActiveDeviceProfile();
if (FApp::ShouldUseThreadingForPerformance() && FPlatformMisc::AllowRenderThread())
{
GUseThreadedRendering = true;
}
#endif
FConfigCacheIni::LoadConsoleVariablesFromINI();
{
DECLARE_SCOPE_CYCLE_COUNTER(TEXT("Platform Initialization"), STAT_PlatformInit, STATGROUP_LoadTime);
// platform specific initialization now that the SystemSettings are loaded
FPlatformMisc::PlatformInit();
FPlatformMemory::Init();
}
// Let LogConsole know what ini file it should use to save its setting on exit.
// We can't use GGameIni inside log console because it's destroyed in the global
// scoped pointer and at that moment GGameIni may already be gone.
if( GLogConsole != nullptr )
{
GLogConsole->SetIniFilename(*GGameIni);
}
#if CHECK_PUREVIRTUALS
FMessageDialog::Open( EAppMsgType::Ok, *NSLOCTEXT("Engine", "Error_PureVirtualsEnabled", "The game cannot run with CHECK_PUREVIRTUALS enabled. Please disable CHECK_PUREVIRTUALS and rebuild the executable.").ToString() );
FPlatformMisc::RequestExit(false);
#endif
#if WITH_ENGINE
// allow for game explorer processing (including parental controls) and firewalls installation
if (!FPlatformMisc::CommandLineCommands())
{
FPlatformMisc::RequestExit(false);
}
bool bIsSeekFreeDedicatedServer = false;
bool bIsRegularClient = false;
if (!bHasEditorToken)
{
// See whether the first token on the command line is a commandlet.
//@hack: We need to set these before calling StaticLoadClass so all required data gets loaded for the commandlets.
GIsClient = true;
GIsServer = true;
#if WITH_EDITOR
GIsEditor = true;
#endif //WITH_EDITOR
PRIVATE_GIsRunningCommandlet = true;
// Allow commandlet rendering and/or audio based on command line switch (too early to let the commandlet itself override this).
PRIVATE_GAllowCommandletRendering = FParse::Param(FCommandLine::Get(), TEXT("AllowCommandletRendering"));
PRIVATE_GAllowCommandletAudio = FParse::Param(FCommandLine::Get(), TEXT("AllowCommandletAudio"));
// We need to disregard the empty token as we try finding Token + "Commandlet" which would result in finding the
// UCommandlet class if Token is empty.
bool bDefinitelyCommandlet = (bTokenDoesNotHaveDash && Token.EndsWith(TEXT("Commandlet")));
if (!bTokenDoesNotHaveDash)
{
if (Token.StartsWith(TEXT("run=")))
{
Token = Token.RightChop(4);
bDefinitelyCommandlet = true;
if (!Token.EndsWith(TEXT("Commandlet")))
{
Token += TEXT("Commandlet");
}
}
}
else
{
if (!bDefinitelyCommandlet)
{
UClass* TempCommandletClass = FindObject<UClass>(ANY_PACKAGE, *(Token+TEXT("Commandlet")), false);
if (TempCommandletClass)
{
check(TempCommandletClass->IsChildOf(UCommandlet::StaticClass())); // ok so you have a class that ends with commandlet that is not a commandlet
Token += TEXT("Commandlet");
bDefinitelyCommandlet = true;
}
}
}
if (!bDefinitelyCommandlet)
{
bIsRegularClient = true;
GIsClient = true;
GIsServer = false;
#if WITH_EDITORONLY_DATA
GIsEditor = false;
#endif
PRIVATE_GIsRunningCommandlet = false;
}
}
if (IsRunningDedicatedServer())
{
GIsClient = false;
GIsServer = true;
PRIVATE_GIsRunningCommandlet = false;
#if WITH_EDITOR
GIsEditor = false;
#endif
bIsSeekFreeDedicatedServer = FPlatformProperties::RequiresCookedData();
}
// If std out device hasn't been initialized yet (there was no -stdout param in the command line) and
// we meet all the criteria, initialize it now.
if (!GScopedStdOut && !bHasEditorToken && !bIsRegularClient && !IsRunningDedicatedServer())
{
InitializeStdOutDevice();
}
if (!GNewAsyncIO)
{
FIOSystem::Get(); // force it to be created if it isn't already
}
// allow the platform to start up any features it may need
IPlatformFeaturesModule::Get();
// Init physics engine before loading anything, in case we want to do things like cook during post-load.
InitGamePhys();
// Delete temporary files in cache.
FPlatformProcess::CleanFileCache();
#if !UE_BUILD_SHIPPING
GIsDemoMode = FParse::Param( FCommandLine::Get(), TEXT( "DEMOMODE" ) );
#endif
if (bHasEditorToken)
{
#if WITH_EDITOR
// We're the editor.
GIsClient = true;
GIsServer = true;
GIsEditor = true;
PRIVATE_GIsRunningCommandlet = false;
GWarn = &UnrealEdWarn;
#else
FMessageDialog::Open( EAppMsgType::Ok, NSLOCTEXT("Engine", "EditorNotSupported", "Editor not supported in this mode."));
FPlatformMisc::RequestExit(false);
return 1;
#endif //WITH_EDITOR
}
#endif // WITH_ENGINE
// If we're not in the editor stop collecting the backlog now that we know
if (!GIsEditor)
{
GLog->EnableBacklog( false );
}
#if WITH_ENGINE
EndInitTextLocalization();
if (FApp::ShouldUseThreadingForPerformance() && FPlatformMisc::AllowAudioThread())
{
bool bUseThreadedAudio = false;
if (!GIsEditor)
{
GConfig->GetBool(TEXT("Audio"), TEXT("UseAudioThread"), bUseThreadedAudio, GEngineIni);
}
FAudioThread::SetUseThreadedAudio(bUseThreadedAudio);
}
if (FPlatformProcess::SupportsMultithreading() && !IsRunningDedicatedServer() && (bIsRegularClient || bHasEditorToken))
{
FPlatformSplash::Show();
}
if (!IsRunningDedicatedServer() && (bHasEditorToken || bIsRegularClient))
{
// Init platform application
FSlateApplication::Create();
}
else
{
// If we're not creating the slate application there is some basic initialization
// that it does that still must be done
EKeys::Initialize();
FCoreStyle::ResetToDefault();
}
if (GIsEditor)
{
// The editor makes use of all cultures in its UI, so pre-load the resource data now to avoid a hitch later
FInternationalization::Get().LoadAllCultureData();
}
FScopedSlowTask SlowTask(100, NSLOCTEXT("EngineLoop", "EngineLoop_Initializing", "Initializing..."));
SlowTask.EnterProgressFrame(10);
#if USE_LOCALIZED_PACKAGE_CACHE
FPackageLocalizationManager::Get().InitializeFromLazyCallback([](FPackageLocalizationManager& InPackageLocalizationManager)
{
InPackageLocalizationManager.InitializeFromCache(MakeShareable(new FEnginePackageLocalizationCache()));
});
#endif // USE_LOCALIZED_PACKAGE_CACHE
// Initialize the RHI.
RHIInit(bHasEditorToken);
if (!FPlatformProperties::RequiresCookedData())
{
check(!GShaderCompilingManager);
GShaderCompilingManager = new FShaderCompilingManager();
check(!GDistanceFieldAsyncQueue);
GDistanceFieldAsyncQueue = new FDistanceFieldAsyncQueue();
}
{
DECLARE_SCOPE_CYCLE_COUNTER(TEXT("Initial UObject load"), STAT_InitialUObjectLoad, STATGROUP_LoadTime);
// Initialize shader types before loading any shaders
InitializeShaderTypes();
SlowTask.EnterProgressFrame(30);
// Load the global shaders.
// if (!IsRunningCommandlet())
// hack: don't load global shaders if we are cooking we will load the shaders for the correct platform later
FString Commandline = FCommandLine::Get();
if (!IsRunningDedicatedServer() &&
Commandline.Contains(TEXT("cookcommandlet")) == false &&
Commandline.Contains(TEXT("run=cook")) == false )
// if (FParse::Param(FCommandLine::Get(), TEXT("Multiprocess")) == false)
{
if (GetGlobalShaderMap(GMaxRHIFeatureLevel) == nullptr && GIsRequestingExit)
{
// This means we can't continue without the global shader map.
return 1;
}
}
else if (FPlatformProperties::RequiresCookedData() == false)
{
GetDerivedDataCacheRef();
}
// If platforms support early movie playback we have to start the rendering thread much earlier
#if PLATFORM_SUPPORTS_EARLY_MOVIE_PLAYBACK
RHIPostInit();
if(GUseThreadedRendering)
{
if(GRHISupportsRHIThread)
{
const bool DefaultUseRHIThread = true;
GUseRHIThread = DefaultUseRHIThread;
if(FParse::Param(FCommandLine::Get(), TEXT("rhithread")))
{
GUseRHIThread = true;
}
else if(FParse::Param(FCommandLine::Get(), TEXT("norhithread")))
{
GUseRHIThread = false;
}
}
StartRenderingThread();
}
#endif
#if !UE_SERVER// && !UE_EDITOR
if(!IsRunningDedicatedServer() && !IsRunningCommandlet())
{
TSharedRef<FSlateRenderer> SlateRenderer = GUsingNullRHI ?
FModuleManager::Get().LoadModuleChecked<ISlateNullRendererModule>("SlateNullRenderer").CreateSlateNullRenderer() :
FModuleManager::Get().GetModuleChecked<ISlateRHIRendererModule>("SlateRHIRenderer").CreateSlateRHIRenderer();
// If Slate is being used, initialize the renderer after RHIInit
FSlateApplication& CurrentSlateApp = FSlateApplication::Get();
CurrentSlateApp.InitializeRenderer(SlateRenderer);
// Create the engine font services now that the Slate renderer is ready
FEngineFontServices::Create();
GetMoviePlayer()->SetSlateRenderer(SlateRenderer);
// allow the movie player to load a sequence from the .inis (a PreLoadingScreen module could have already initialized a sequence, in which case
// it wouldn't have anything in it's .ini file)
GetMoviePlayer()->SetupLoadingScreenFromIni();
if(GetMoviePlayer()->HasEarlyStartupMovie())
{
GetMoviePlayer()->Initialize();
// hide splash screen now
FPlatformMisc::PlatformPostInit(false);
// only allowed to play any movies marked as early startup. These movies or widgets can have no interaction whatsoever with uobjects or engine features
GetMoviePlayer()->PlayEarlyStartupMovies();
}
}
#endif
// In order to be able to use short script package names get all script
// package names from ini files and register them with FPackageName system.
FPackageName::RegisterShortPackageNamesForUObjectModules();
SlowTask.EnterProgressFrame(5);
// Make sure all UObject classes are registered and default properties have been initialized
ProcessNewlyLoadedUObjects();
#if USE_LOCALIZED_PACKAGE_CACHE
// CoreUObject is definitely available now, so make sure the package localization cache is available
// This may have already been initialized from the CDO creation from ProcessNewlyLoadedUObjects
FPackageLocalizationManager::Get().PerformLazyInitialization();
#endif // USE_LOCALIZED_PACKAGE_CACHE
// Default materials may have been loaded due to dependencies when loading
// classes and class default objects. If not, do so now.
UMaterialInterface::InitDefaultMaterials();
UMaterialInterface::AssertDefaultMaterialsExist();
UMaterialInterface::AssertDefaultMaterialsPostLoaded();
}
// Initialize the texture streaming system (needs to happen after RHIInit and ProcessNewlyLoadedUObjects).
IStreamingManager::Get();
SlowTask.EnterProgressFrame(5);
// Tell the module manager is may now process newly-loaded UObjects when new C++ modules are loaded
FModuleManager::Get().StartProcessingNewlyLoadedObjects();
// Setup GC optimizations
if (bIsSeekFreeDedicatedServer || bHasEditorToken)
{
GUObjectArray.DisableDisregardForGC();
}
SlowTask.EnterProgressFrame(10);
if ( !LoadStartupCoreModules() )
{
// At least one startup module failed to load, return 1 to indicate an error
return 1;
}
SlowTask.EnterProgressFrame(10);
// Load up all modules that need to hook into the loading screen
if (!IProjectManager::Get().LoadModulesForProject(ELoadingPhase::PreLoadingScreen) || !IPluginManager::Get().LoadModulesForEnabledPlugins(ELoadingPhase::PreLoadingScreen))
{
return 1;
}
#if !UE_SERVER// && !UE_EDITOR
if(!IsRunningDedicatedServer() && !IsRunningCommandlet() && !GetMoviePlayer()->IsMovieCurrentlyPlaying())
{
GetMoviePlayer()->Initialize();
// Play any non-early startup loading movies.
GetMoviePlayer()->PlayMovie();
}
#endif
#if !UE_SERVER
if ( !IsRunningDedicatedServer() )
{
// do any post appInit processing, before the render thread is started.
FPlatformMisc::PlatformPostInit(!GetMoviePlayer()->IsMovieCurrentlyPlaying());
}
else
#endif
{
// do any post appInit processing, before the render thread is started.
FPlatformMisc::PlatformPostInit(true);
}
SlowTask.EnterProgressFrame(5);
#if !PLATFORM_SUPPORTS_EARLY_MOVIE_PLAYBACK
RHIPostInit();
if (GUseThreadedRendering)
{
if (GRHISupportsRHIThread)
{
const bool DefaultUseRHIThread = true;
GUseRHIThread = DefaultUseRHIThread;
if (FParse::Param(FCommandLine::Get(),TEXT("rhithread")))
{
GUseRHIThread = true;
}
else if (FParse::Param(FCommandLine::Get(),TEXT("norhithread")))
{
GUseRHIThread = false;
}
}
StartRenderingThread();
}
#endif // !PLATFORM_SUPPORTS_EARLY_MOVIE_PLAYBACK
#if WITH_EDITOR
// We need to mount the shared resources for templates (if there are any) before we try and load and game classes
FUnrealEdMisc::Get().MountTemplateSharedPaths();
#endif
if ( !LoadStartupModules() )
{
// At least one startup module failed to load, return 1 to indicate an error
return 1;
}
// load up the seek-free startup packages
if ( !FStartupPackages::LoadAll() )
{
// At least one startup package failed to load, return 1 to indicate an error
return 1;
}
#endif // WITH_ENGINE
#if WITH_COREUOBJECT
if (GUObjectArray.IsOpenForDisregardForGC())
{
GUObjectArray.CloseDisregardForGC();
}
#endif // WITH_COREUOBJECT
#if WITH_ENGINE
if (UOnlineEngineInterface::Get()->IsLoaded())
{
SetIsServerForOnlineSubsystemsDelegate(FQueryIsRunningServer::CreateStatic(&IsServerDelegateForOSS));
}
SlowTask.EnterProgressFrame(5);
if (!bHasEditorToken)
{
UClass* CommandletClass = nullptr;
if (!bIsRegularClient)
{
CommandletClass = FindObject<UClass>(ANY_PACKAGE,*Token,false);
if (!CommandletClass)
{
if (GLogConsole && !GIsSilent)
{
GLogConsole->Show(true);
}
UE_LOG(LogInit, Error, TEXT("%s looked like a commandlet, but we could not find the class."), *Token);
GIsRequestingExit = true;
return 1;
}
#if PLATFORM_WINDOWS || PLATFORM_MAC || PLATFORM_LINUX
extern bool GIsConsoleExecutable;
if (GIsConsoleExecutable)
{
if (GLogConsole != nullptr && GLogConsole->IsAttached())
{
GLog->RemoveOutputDevice(GLogConsole);
}
// Setup Ctrl-C handler for console application
FPlatformMisc::SetGracefulTerminationHandler();
}
else
#endif
{
// Bring up console unless we're a silent build.
if( GLogConsole && !GIsSilent )
{
GLogConsole->Show( true );
}
}
// print output immediately
setvbuf(stdout, nullptr, _IONBF, 0);
UE_LOG(LogInit, Log, TEXT("Executing %s"), *CommandletClass->GetFullName() );
// Allow commandlets to individually override those settings.
UCommandlet* Default = CastChecked<UCommandlet>(CommandletClass->GetDefaultObject());
if ( GIsRequestingExit )
{
// commandlet set GIsRequestingExit during construction
return 1;
}
GIsClient = Default->IsClient;
GIsServer = Default->IsServer;
#if WITH_EDITOR
GIsEditor = Default->IsEditor;
#else
if (Default->IsEditor)
{
UE_LOG(LogInit, Error, TEXT("Cannot run editor commandlet %s with game executable."), *CommandletClass->GetFullName());
GIsRequestingExit = true;
return 1;
}
#endif
PRIVATE_GIsRunningCommandlet = true;
// Reset aux log if we don't want to log to the console window.
if( !Default->LogToConsole )
{
GLog->RemoveOutputDevice( GLogConsole );
}
// allow the commandlet the opportunity to create a custom engine
CommandletClass->GetDefaultObject<UCommandlet>()->CreateCustomEngine(CommandletCommandLine);
if ( GEngine == nullptr )
{
#if WITH_EDITOR
if ( GIsEditor )
{
FString EditorEngineClassName;
GConfig->GetString(TEXT("/Script/Engine.Engine"), TEXT("EditorEngine"), EditorEngineClassName, GEngineIni);
UClass* EditorEngineClass = StaticLoadClass( UEditorEngine::StaticClass(), nullptr, *EditorEngineClassName);
if (EditorEngineClass == nullptr)
{
UE_LOG(LogInit, Fatal, TEXT("Failed to load Editor Engine class '%s'."), *EditorEngineClassName);
}
GEngine = GEditor = NewObject<UEditorEngine>(GetTransientPackage(), EditorEngineClass);
GEngine->ParseCommandline();
UE_LOG(LogInit, Log, TEXT("Initializing Editor Engine..."));
GEditor->InitEditor(this);
UE_LOG(LogInit, Log, TEXT("Initializing Editor Engine Completed"));
}
else
#endif
{
FString GameEngineClassName;
GConfig->GetString(TEXT("/Script/Engine.Engine"), TEXT("GameEngine"), GameEngineClassName, GEngineIni);
UClass* EngineClass = StaticLoadClass( UEngine::StaticClass(), nullptr, *GameEngineClassName);
if (EngineClass == nullptr)
{
UE_LOG(LogInit, Fatal, TEXT("Failed to load Engine class '%s'."), *GameEngineClassName);
}
// must do this here so that the engine object that we create on the next line receives the correct property values
GEngine = NewObject<UEngine>(GetTransientPackage(), EngineClass);
check(GEngine);
GEngine->ParseCommandline();
UE_LOG(LogInit, Log, TEXT("Initializing Game Engine..."));
GEngine->Init(this);
UE_LOG(LogInit, Log, TEXT("Initializing Game Engine Completed"));
}
}
// Load all the post-engine init modules
ensure(IProjectManager::Get().LoadModulesForProject(ELoadingPhase::PostEngineInit));
ensure(IPluginManager::Get().LoadModulesForEnabledPlugins(ELoadingPhase::PostEngineInit));
//run automation smoke tests now that the commandlet has had a chance to override the above flags and GEngine is available
#if !PLATFORM_HTML5 && !PLATFORM_HTML5_WIN32
FAutomationTestFramework::Get().RunSmokeTests();
#endif
UCommandlet* Commandlet = NewObject<UCommandlet>(GetTransientPackage(), CommandletClass);
check(Commandlet);
Commandlet->AddToRoot();
// Execute the commandlet.
double CommandletExecutionStartTime = FPlatformTime::Seconds();
// Commandlets don't always handle -run= properly in the commandline so we'll provide them
// with a custom version that doesn't have it.
Commandlet->ParseParms( CommandletCommandLine );
#if STATS
// We have to close the scope, otherwise we will end with broken stats.
CycleCount_AfterStats.StopAndResetStatId();
#endif // STATS
FStats::TickCommandletStats();
int32 ErrorLevel = Commandlet->Main( CommandletCommandLine );
FStats::TickCommandletStats();
GIsRequestingExit = true;
// Log warning/ error summary.
if( Commandlet->ShowErrorCount )
{
TArray<FString> AllErrors;
TArray<FString> AllWarnings;
GWarn->GetErrors(AllErrors);
GWarn->GetWarnings(AllWarnings);
if (AllErrors.Num() || AllWarnings.Num())
{
SET_WARN_COLOR(COLOR_WHITE);
UE_LOG(LogInit, Display, TEXT(""));
UE_LOG(LogInit, Display, TEXT("Warning/Error Summary (Unique only)"));
UE_LOG(LogInit, Display, TEXT("-----------------------------------"));
const int32 MaxMessagesToShow = (GIsBuildMachine || FParse::Param(FCommandLine::Get(), TEXT("DUMPALLWARNINGS"))) ?
FMath::Max(AllErrors.Num(), AllWarnings.Num()) : 50;
TSet<FString> ShownMessages;
ShownMessages.Empty(MaxMessagesToShow);
SET_WARN_COLOR(COLOR_RED);
for (const FString& ErrorMessage : AllErrors)
{
bool bAlreadyShown = false;
ShownMessages.Add(ErrorMessage, &bAlreadyShown);
if (!bAlreadyShown)
{
if (ShownMessages.Num() > MaxMessagesToShow)
{
SET_WARN_COLOR(COLOR_WHITE);
UE_CLOG(MaxMessagesToShow < AllErrors.Num(), LogInit, Display, TEXT("NOTE: Only first %d errors displayed."), MaxMessagesToShow);
break;
}
UE_LOG(LogInit, Display, TEXT("%s"), *ErrorMessage);
}
}
SET_WARN_COLOR(COLOR_YELLOW);
ShownMessages.Empty(MaxMessagesToShow);
for (const FString& WarningMessage : AllWarnings)
{
bool bAlreadyShown = false;
ShownMessages.Add(WarningMessage, &bAlreadyShown);
if (!bAlreadyShown)
{
if (ShownMessages.Num() > MaxMessagesToShow)
{
SET_WARN_COLOR(COLOR_WHITE);
UE_CLOG(MaxMessagesToShow < AllWarnings.Num(), LogInit, Display, TEXT("NOTE: Only first %d warnings displayed."), MaxMessagesToShow);
break;
}
UE_LOG(LogInit, Display, TEXT("%s"), *WarningMessage);
}
}
}
UE_LOG(LogInit, Display, TEXT(""));
if( ErrorLevel != 0 )
{
SET_WARN_COLOR(COLOR_RED);
UE_LOG(LogInit, Display, TEXT("Commandlet->Main return this error code: %d"), ErrorLevel );
UE_LOG(LogInit, Display, TEXT("With %d error(s), %d warning(s)"), AllErrors.Num(), AllWarnings.Num() );
}
else if( ( AllErrors.Num() == 0 ) )
{
SET_WARN_COLOR(AllWarnings.Num() ? COLOR_YELLOW : COLOR_GREEN);
UE_LOG(LogInit, Display, TEXT("Success - %d error(s), %d warning(s)"), AllErrors.Num(), AllWarnings.Num() );
}
else
{
SET_WARN_COLOR(COLOR_RED);
UE_LOG(LogInit, Display, TEXT("Failure - %d error(s), %d warning(s)"), AllErrors.Num(), AllWarnings.Num() );
ErrorLevel = 1;
}
CLEAR_WARN_COLOR();
}
else
{
UE_LOG(LogInit, Display, TEXT("Finished.") );
}
double CommandletExecutionTime = FPlatformTime::Seconds() - CommandletExecutionStartTime;
UE_LOG(LogInit, Display, LINE_TERMINATOR TEXT( "Execution of commandlet took: %.2f seconds"), CommandletExecutionTime );
// We're ready to exit!
return ErrorLevel;
}
else
{
// We're a regular client.
check(bIsRegularClient);
if (bTokenDoesNotHaveDash)
{
// here we give people a reasonable warning if they tried to use the short name of a commandlet
UClass* TempCommandletClass = FindObject<UClass>(ANY_PACKAGE,*(Token+TEXT("Commandlet")),false);
if (TempCommandletClass)
{
UE_LOG(LogInit, Fatal, TEXT("You probably meant to call a commandlet. Please use the full name %s."), *(Token+TEXT("Commandlet")));
}
}
}
}
// exit if wanted.
if( GIsRequestingExit )
{
if ( GEngine != nullptr )
{
GEngine->PreExit();
}
AppPreExit();
// appExit is called outside guarded block.
return 1;
}
FString MatineeName;
if(FParse::Param(FCommandLine::Get(),TEXT("DUMPMOVIE")) || FParse::Value(FCommandLine::Get(), TEXT("-MATINEESSCAPTURE="), MatineeName))
{
// -1: remain on
GIsDumpingMovie = -1;
}
// If dumping movie then we do NOT want on-screen messages
GAreScreenMessagesEnabled = !GIsDumpingMovie && !GIsDemoMode;
#if !UE_BUILD_SHIPPING
if (FParse::Param(FCommandLine::Get(),TEXT("NOSCREENMESSAGES")))
{
GAreScreenMessagesEnabled = false;
}
// Don't update INI files if benchmarking or -noini
if( FApp::IsBenchmarking() || FParse::Param(FCommandLine::Get(),TEXT("NOINI")))
{
GConfig->Detach( GEngineIni );
GConfig->Detach( GInputIni );
GConfig->Detach( GGameIni );
GConfig->Detach( GEditorIni );
}
#endif // !UE_BUILD_SHIPPING
delete [] CommandLineCopy;
// initialize the pointer, as it is deleted before being assigned in the first frame
PendingCleanupObjects = nullptr;
// Initialize profile visualizers.
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
FModuleManager::Get().LoadModule(TEXT("TaskGraph"));
if (FPlatformProcess::SupportsMultithreading())
{
FModuleManager::Get().LoadModule(TEXT("ProfilerService"));
FModuleManager::Get().GetModuleChecked<IProfilerServiceModule>("ProfilerService").CreateProfilerServiceManager();
}
#endif
// Init HighRes screenshot system, unless running on server
if (!IsRunningDedicatedServer())
{
GetHighResScreenshotConfig().Init();
}
#else // WITH_ENGINE
EndInitTextLocalization();
#if USE_LOCALIZED_PACKAGE_CACHE
FPackageLocalizationManager::Get().InitializeFromDefaultCache();
#endif // USE_LOCALIZED_PACKAGE_CACHE
FPlatformMisc::PlatformPostInit();
#endif // WITH_ENGINE
//run automation smoke tests now that everything is setup to run
FAutomationTestFramework::Get().RunSmokeTests();
// Note we still have 20% remaining on the slow task: this will be used by the Editor/Engine initialization next
return 0;
}
bool FEngineLoop::LoadCoreModules()
{
// Always attempt to load CoreUObject. It requires additional pre-init which is called from its module's StartupModule method.
#if WITH_COREUOBJECT
bool bResult = FModuleManager::Get().LoadModule(TEXT("CoreUObject")).IsValid();
return bResult;
#else
return true;
#endif
}
void FEngineLoop::LoadPreInitModules()
{
DECLARE_SCOPE_CYCLE_COUNTER(TEXT("Loading PreInit Modules"), STAT_PreInitModules, STATGROUP_LoadTime);
// GGetMapNameDelegate is initialized here
#if WITH_ENGINE
FModuleManager::Get().LoadModule(TEXT("Engine"));
FModuleManager::Get().LoadModule(TEXT("Renderer"));
FModuleManager::Get().LoadModule(TEXT("AnimGraphRuntime"));
FPlatformMisc::LoadPreInitModules();
#if !UE_SERVER
if (!IsRunningDedicatedServer() )
{
if (!GUsingNullRHI)
{
// This needs to be loaded before InitializeShaderTypes is called
FModuleManager::Get().LoadModuleChecked<ISlateRHIRendererModule>("SlateRHIRenderer");
}
}
#endif
FModuleManager::Get().LoadModule(TEXT("Landscape"));
// Initialize ShaderCore before loading or compiling any shaders,
// But after Renderer and any other modules which implement shader types.
FModuleManager::Get().LoadModule(TEXT("ShaderCore"));
#if WITH_EDITORONLY_DATA
// Load the texture compressor module before any textures load. They may
// compress asynchronously and that can lead to a race condition.
FModuleManager::Get().LoadModule(TEXT("TextureCompressor"));
#endif
#endif // WITH_ENGINE
#if (WITH_EDITOR && !(UE_BUILD_SHIPPING || UE_BUILD_TEST))
// Load audio editor module before engine class CDOs are loaded
FModuleManager::Get().LoadModule(TEXT("AudioEditor"));
#endif
}
#if WITH_ENGINE
bool FEngineLoop::LoadStartupCoreModules()
{
FScopedSlowTask SlowTask(100);
DECLARE_SCOPE_CYCLE_COUNTER(TEXT("Loading Startup Modules"), STAT_StartupModules, STATGROUP_LoadTime);
bool bSuccess = true;
// Load all Runtime modules
SlowTask.EnterProgressFrame(10);
{
FModuleManager::Get().LoadModule(TEXT("Core"));
FModuleManager::Get().LoadModule(TEXT("Networking"));
}
SlowTask.EnterProgressFrame(10);
FPlatformMisc::LoadStartupModules();
// initialize messaging
SlowTask.EnterProgressFrame(10);
if (FPlatformProcess::SupportsMultithreading())
{
FModuleManager::LoadModuleChecked<IMessagingModule>("Messaging");
}
SlowTask.EnterProgressFrame(10);
#if WITH_EDITOR
FModuleManager::LoadModuleChecked<IEditorStyleModule>("EditorStyle");
#endif //WITH_EDITOR
// Load UI modules
SlowTask.EnterProgressFrame(10);
if ( !IsRunningDedicatedServer() )
{
FModuleManager::Get().LoadModule("Slate");
#if !UE_BUILD_SHIPPING
// Need to load up the SlateReflector module to initialize the WidgetSnapshotService
FModuleManager::Get().LoadModule("SlateReflector");
#endif // !UE_BUILD_SHIPPING
}
#if WITH_EDITOR
// In dedicated server builds with the editor, we need to load UMG/UMGEditor for compiling blueprints.
// UMG must be loaded for runtime and cooking.
FModuleManager::Get().LoadModule("UMG");
#else
if ( !IsRunningDedicatedServer() )
{
// UMG must be loaded for runtime and cooking.
FModuleManager::Get().LoadModule("UMG");
}
#endif //WITH_EDITOR
// Load all Development modules
SlowTask.EnterProgressFrame(20);
if (!IsRunningDedicatedServer())
{
#if WITH_UNREAL_DEVELOPER_TOOLS
FModuleManager::Get().LoadModule("MessageLog");
FModuleManager::Get().LoadModule("CollisionAnalyzer");
#endif //WITH_UNREAL_DEVELOPER_TOOLS
}
#if WITH_UNREAL_DEVELOPER_TOOLS
FModuleManager::Get().LoadModule("FunctionalTesting");
#endif //WITH_UNREAL_DEVELOPER_TOOLS
SlowTask.EnterProgressFrame(30);
#if (WITH_EDITOR && !(UE_BUILD_SHIPPING || UE_BUILD_TEST))
// HACK: load BT editor as early as possible for statically initialized assets (non cooked BT assets needs it)
// cooking needs this module too
FModuleManager::Get().LoadModule(TEXT("BehaviorTreeEditor"));
// Ability tasks are based on GameplayTasks, so we need to make sure that module is loaded as well
FModuleManager::Get().LoadModule(TEXT("GameplayTasksEditor"));
IAudioEditorModule* AudioEditorModule = &FModuleManager::LoadModuleChecked<IAudioEditorModule>("AudioEditor");
AudioEditorModule->RegisterAssetActions();
if( !IsRunningDedicatedServer() )
{
// VREditor needs to be loaded in non-server editor builds early, so engine content Blueprints can be loaded during DDC generation
FModuleManager::Get().LoadModule(TEXT("VREditor"));
}
// -----------------------------------------------------
// HACK: load EQS editor as early as possible for statically initialized assets (non cooked EQS assets needs it)
// cooking needs this module too
bool bEnvironmentQueryEditor = false;
GConfig->GetBool(TEXT("EnvironmentQueryEd"), TEXT("EnableEnvironmentQueryEd"), bEnvironmentQueryEditor, GEngineIni);
if (bEnvironmentQueryEditor
#if WITH_EDITOR
|| GetDefault<UEditorExperimentalSettings>()->bEQSEditor
#endif // WITH_EDITOR
)
{
FModuleManager::Get().LoadModule(TEXT("EnvironmentQueryEditor"));
}
// We need this for blueprint projects that have online functionality.
//FModuleManager::Get().LoadModule(TEXT("OnlineBlueprintSupport"));
if (IsRunningCommandlet())
{
FModuleManager::Get().LoadModule(TEXT("IntroTutorials"));
FModuleManager::Get().LoadModule(TEXT("Blutility"));
}
#endif //(WITH_EDITOR && !(UE_BUILD_SHIPPING || UE_BUILD_TEST))
#if WITH_ENGINE
// Load runtime client modules (which are also needed at cook-time)
if( !IsRunningDedicatedServer() )
{
FModuleManager::Get().LoadModule(TEXT("GameLiveStreaming"));
FModuleManager::Get().LoadModule(TEXT("MediaAssets"));
}
#endif
return bSuccess;
}
bool FEngineLoop::LoadStartupModules()
{
FScopedSlowTask SlowTask(3);
SlowTask.EnterProgressFrame(1);
// Load any modules that want to be loaded before default modules are loaded up.
if (!IProjectManager::Get().LoadModulesForProject(ELoadingPhase::PreDefault) || !IPluginManager::Get().LoadModulesForEnabledPlugins(ELoadingPhase::PreDefault))
{
return false;
}
SlowTask.EnterProgressFrame(1);
// Load modules that are configured to load in the default phase
if (!IProjectManager::Get().LoadModulesForProject(ELoadingPhase::Default) || !IPluginManager::Get().LoadModulesForEnabledPlugins(ELoadingPhase::Default))
{
return false;
}
SlowTask.EnterProgressFrame(1);
// Load any modules that want to be loaded after default modules are loaded up.
if (!IProjectManager::Get().LoadModulesForProject(ELoadingPhase::PostDefault) || !IPluginManager::Get().LoadModulesForEnabledPlugins(ELoadingPhase::PostDefault))
{
return false;
}
return true;
}
void FEngineLoop::InitTime()
{
// Init variables used for benchmarking and ticking.
FApp::SetCurrentTime(FPlatformTime::Seconds());
MaxFrameCounter = 0;
MaxTickTime = 0;
TotalTickTime = 0;
LastFrameCycles = FPlatformTime::Cycles();
float FloatMaxTickTime = 0;
#if !UE_BUILD_SHIPPING
FParse::Value(FCommandLine::Get(),TEXT("SECONDS="),FloatMaxTickTime);
MaxTickTime = FloatMaxTickTime;
// look of a version of seconds that only is applied if FApp::IsBenchmarking() is set. This makes it easier on
// say, iOS, where we have a toggle setting to enable benchmarking, but don't want to have to make user
// also disable the seconds setting as well. -seconds= will exit the app after time even if benchmarking
// is not enabled
// NOTE: This will override -seconds= if it's specified
if (FApp::IsBenchmarking())
{
if (FParse::Value(FCommandLine::Get(),TEXT("BENCHMARKSECONDS="),FloatMaxTickTime) && FloatMaxTickTime)
{
MaxTickTime = FloatMaxTickTime;
}
}
// Use -FPS=X to override fixed tick rate if e.g. -BENCHMARK is used.
float FixedFPS = 0;
FParse::Value(FCommandLine::Get(),TEXT("FPS="),FixedFPS);
if( FixedFPS > 0 )
{
FApp::SetFixedDeltaTime(1 / FixedFPS);
}
#endif // !UE_BUILD_SHIPPING
// convert FloatMaxTickTime into number of frames (using 1 / FApp::GetFixedDeltaTime() to convert fps to seconds )
MaxFrameCounter = FMath::TruncToInt(MaxTickTime / FApp::GetFixedDeltaTime());
}
//called via FCoreDelegates::StarvedGameLoop
void GameLoopIsStarved()
{
FlushPendingDeleteRHIResources_GameThread();
FStats::AdvanceFrame( true, FStats::FOnAdvanceRenderingThreadStats::CreateStatic( &AdvanceRenderingThreadStatsGT ) );
}
int32 FEngineLoop::Init()
{
CheckImageIntegrity();
DECLARE_SCOPE_CYCLE_COUNTER( TEXT( "FEngineLoop::Init" ), STAT_FEngineLoop_Init, STATGROUP_LoadTime );
FScopedSlowTask SlowTask(100);
SlowTask.EnterProgressFrame(10);
// Figure out which UEngine variant to use.
UClass* EngineClass = nullptr;
if( !GIsEditor )
{
// We're the game.
FString GameEngineClassName;
GConfig->GetString(TEXT("/Script/Engine.Engine"), TEXT("GameEngine"), GameEngineClassName, GEngineIni);
EngineClass = StaticLoadClass( UGameEngine::StaticClass(), nullptr, *GameEngineClassName);
if (EngineClass == nullptr)
{
UE_LOG(LogInit, Fatal, TEXT("Failed to load UnrealEd Engine class '%s'."), *GameEngineClassName);
}
GEngine = NewObject<UEngine>(GetTransientPackage(), EngineClass);
}
else
{
#if WITH_EDITOR
// We're UnrealEd.
FString UnrealEdEngineClassName;
GConfig->GetString(TEXT("/Script/Engine.Engine"), TEXT("UnrealEdEngine"), UnrealEdEngineClassName, GEngineIni);
EngineClass = StaticLoadClass(UUnrealEdEngine::StaticClass(), nullptr, *UnrealEdEngineClassName);
if (EngineClass == nullptr)
{
UE_LOG(LogInit, Fatal, TEXT("Failed to load UnrealEd Engine class '%s'."), *UnrealEdEngineClassName);
}
GEngine = GEditor = GUnrealEd = NewObject<UUnrealEdEngine>(GetTransientPackage(), EngineClass);
#else
check(0);
#endif
}
check( GEngine );
GetMoviePlayer()->PassLoadingScreenWindowBackToGame();
GEngine->ParseCommandline();
InitTime();
SlowTask.EnterProgressFrame(60);
GEngine->Init(this);
UEngine::OnPostEngineInit.Broadcast();
SlowTask.EnterProgressFrame(30);
// initialize engine instance discovery
if (FPlatformProcess::SupportsMultithreading())
{
if (!IsRunningCommandlet())
{
SessionService = FModuleManager::LoadModuleChecked<ISessionServicesModule>("SessionServices").GetSessionService();
SessionService->Start();
}
EngineService = new FEngineService();
}
// Load all the post-engine init modules
if (!IProjectManager::Get().LoadModulesForProject(ELoadingPhase::PostEngineInit) || !IPluginManager::Get().LoadModulesForEnabledPlugins(ELoadingPhase::PostEngineInit))
{
GIsRequestingExit = true;
return 1;
}
GEngine->Start();
GetMoviePlayer()->WaitForMovieToFinish();
// initialize automation worker
#if WITH_AUTOMATION_WORKER
FModuleManager::Get().LoadModule("AutomationWorker");
#endif
// Automation tests can be invoked locally in non-editor builds configuration (e.g. performance profiling in Test configuration)
#if WITH_ENGINE && !UE_BUILD_SHIPPING
FModuleManager::Get().LoadModule("AutomationController");
FModuleManager::GetModuleChecked<IAutomationControllerModule>("AutomationController").Init();
#endif
#if WITH_EDITOR
if (GIsEditor)
{
FModuleManager::Get().LoadModule(TEXT("ProfilerClient"));
}
FModuleManager::Get().LoadModule(TEXT("SequenceRecorder"));
FModuleManager::Get().LoadModule(TEXT("SequenceRecorderSections"));
#endif
GIsRunning = true;
if (!GIsEditor)
{
// hide a couple frames worth of rendering
FViewport::SetGameRenderingEnabled(true, 3);
}
// Begin the async platform hardware survey
GEngine->StartHardwareSurvey();
FCoreDelegates::StarvedGameLoop.BindStatic(&GameLoopIsStarved);
// Ready to measure thread heartbeat
FThreadHeartBeat::Get().Start();
FCoreDelegates::OnFEngineLoopInitComplete.Broadcast();
return 0;
}
void FEngineLoop::Exit()
{
STAT_ADD_CUSTOMMESSAGE_NAME( STAT_NamedMarker, TEXT( "EngineLoop.Exit" ) );
GIsRunning = 0;
GLogConsole = nullptr;
// shutdown visual logger and flush all data
#if ENABLE_VISUAL_LOG
FVisualLogger::Get().Shutdown();
#endif
GetMoviePlayer()->Shutdown();
// Make sure we're not in the middle of loading something.
FlushAsyncLoading();
// Block till all outstanding resource streaming requests are fulfilled.
if (!IStreamingManager::HasShutdown())
{
UTexture2D::CancelPendingTextureStreaming();
IStreamingManager::Get().BlockTillAllRequestsFinished();
}
#if WITH_ENGINE
// shut down messaging
delete EngineService;
EngineService = nullptr;
if (SessionService.IsValid())
{
SessionService->Stop();
SessionService.Reset();
}
if (GDistanceFieldAsyncQueue)
{
GDistanceFieldAsyncQueue->Shutdown();
delete GDistanceFieldAsyncQueue;
}
#endif // WITH_ENGINE
if ( GEngine != nullptr )
{
GEngine->ShutdownAudioDeviceManager();
}
if ( GEngine != nullptr )
{
GEngine->PreExit();
}
// close all windows
FSlateApplication::Shutdown();
#if !UE_SERVER
if ( FEngineFontServices::IsInitialized() )
{
FEngineFontServices::Destroy();
}
#endif
#if !PLATFORM_ANDROID // AppPreExit doesn't work on Android
AppPreExit();
TermGamePhys();
ParticleVertexFactoryPool_FreePool();
#else
// AppPreExit() stops malloc profiler, do it here instead
MALLOC_PROFILER( GMalloc->Exec(nullptr, TEXT("MPROF STOP"), *GLog); );
#endif // !ANDROID
// Stop the rendering thread.
StopRenderingThread();
// Tear down the RHI.
RHIExitAndStopRHIThread();
#if !PLATFORM_ANDROID // UnloadModules doesn't work on Android
#if WITH_ENGINE
// Save the hot reload state
IHotReloadInterface* HotReload = IHotReloadInterface::GetPtr();
if(HotReload != nullptr)
{
HotReload->SaveConfig();
}
#endif
// Unload all modules. Note that this doesn't actually unload the module DLLs (that happens at
// process exit by the OS), but it does call ShutdownModule() on all loaded modules in the reverse
// order they were loaded in, so that systems can unregister and perform general clean up.
FModuleManager::Get().UnloadModulesAtShutdown();
#endif // !ANDROID
// Move earlier?
#if STATS
FThreadStats::StopThread();
#endif
FTaskGraphInterface::Shutdown();
IStreamingManager::Shutdown();
if (!GNewAsyncIO)
{
FIOSystem::Shutdown();
}
}
void FEngineLoop::ProcessLocalPlayerSlateOperations() const
{
FSlateApplication& SlateApp = FSlateApplication::Get();
// For all the game worlds drill down to the player controller for each game viewport and process it's slate operation
for ( const FWorldContext& Context : GEngine->GetWorldContexts() )
{
UWorld* CurWorld = Context.World();
if ( CurWorld && CurWorld->IsGameWorld() )
{
UGameViewportClient* GameViewportClient = CurWorld->GetGameViewport();
TSharedPtr< SViewport > ViewportWidget = GameViewportClient ? GameViewportClient->GetGameViewportWidget() : nullptr;
if ( ViewportWidget.IsValid() )
{
FWidgetPath PathToWidget;
SlateApp.GeneratePathToWidgetUnchecked(ViewportWidget.ToSharedRef(), PathToWidget);
if (PathToWidget.IsValid())
{
for (FConstPlayerControllerIterator Iterator = CurWorld->GetPlayerControllerIterator(); Iterator; ++Iterator)
{
APlayerController* PlayerController = Iterator->Get();
if (PlayerController)
{
ULocalPlayer* LocalPlayer = Cast< ULocalPlayer >(PlayerController->Player);
if (LocalPlayer)
{
FReply& TheReply = LocalPlayer->GetSlateOperations();
SlateApp.ProcessReply(PathToWidget, TheReply, nullptr, nullptr, LocalPlayer->GetControllerId());
TheReply = FReply::Unhandled();
}
}
}
}
}
}
}
}
bool FEngineLoop::ShouldUseIdleMode() const
{
static const auto CVarIdleWhenNotForeground = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("t.IdleWhenNotForeground"));
bool bIdleMode = false;
// Yield cpu usage if desired
if (FApp::IsGame()
&& FPlatformProperties::SupportsWindowedMode()
&& CVarIdleWhenNotForeground->GetValueOnGameThread()
&& !FPlatformProcess::IsThisApplicationForeground())
{
bIdleMode = true;
for (const FWorldContext& Context : GEngine->GetWorldContexts())
{
if (!Context.World()->AreAlwaysLoadedLevelsLoaded())
{
bIdleMode = false;
break;
}
}
}
return bIdleMode;
}
#if !UE_BUILD_SHIPPING && !UE_BUILD_TEST
#include "Containers/StackTracker.h"
static TAutoConsoleVariable<int32> CVarLogGameThreadMallocChurn(
TEXT("LogGameThreadMallocChurn.Enable"),
0,
TEXT("If > 0, then collect sample game thread malloc, realloc and free, periodically print a report of the worst offenders."));
static TAutoConsoleVariable<int32> CVarLogGameThreadMallocChurn_PrintFrequency(
TEXT("LogGameThreadMallocChurn.PrintFrequency"),
300,
TEXT("Number of frames between churn reports."));
static TAutoConsoleVariable<int32> CVarLogGameThreadMallocChurn_Threshhold(
TEXT("LogGameThreadMallocChurn.Threshhold"),
10,
TEXT("Minimum average number of allocs per frame to include in the report."));
static TAutoConsoleVariable<int32> CVarLogGameThreadMallocChurn_SampleFrequency(
TEXT("LogGameThreadMallocChurn.SampleFrequency"),
100,
TEXT("Number of allocs to skip between samples. This is used to prevent churn sampling from slowing the game down too much."));
static TAutoConsoleVariable<int32> CVarLogGameThreadMallocChurn_StackIgnore(
TEXT("LogGameThreadMallocChurn.StackIgnore"),
2,
TEXT("Number of items to discard from the top of a stack frame."));
static TAutoConsoleVariable<int32> CVarLogGameThreadMallocChurn_RemoveAliases(
TEXT("LogGameThreadMallocChurn.RemoveAliases"),
1,
TEXT("If > 0 then remove aliases from the counting process. This essentialy merges addresses that have the same human readable string. It is slower."));
static TAutoConsoleVariable<int32> CVarLogGameThreadMallocChurn_StackLen(
TEXT("LogGameThreadMallocChurn.StackLen"),
3,
TEXT("Maximum number of stack frame items to keep. This improves aggregation because calls that originate from multiple places but end up in the same place will be accounted together."));
extern CORE_API TFunction<void(int32)>* GGameThreadMallocHook;
struct FScopedSampleMallocChurn
{
static FStackTracker GGameThreadMallocChurnTracker;
static uint64 DumpFrame;
bool bEnabled;
int32 CountDown;
TFunction<void(int32)> Hook;
FScopedSampleMallocChurn()
: bEnabled(CVarLogGameThreadMallocChurn.GetValueOnGameThread() > 0)
, CountDown(CVarLogGameThreadMallocChurn_SampleFrequency.GetValueOnGameThread())
, Hook(
[this](int32 Index)
{
if (--CountDown <= 0)
{
CountDown = CVarLogGameThreadMallocChurn_SampleFrequency.GetValueOnGameThread();
CollectSample();
}
}
)
{
if (bEnabled)
{
check(IsInGameThread());
check(!GGameThreadMallocHook);
if (!DumpFrame)
{
DumpFrame = GFrameCounter + CVarLogGameThreadMallocChurn_PrintFrequency.GetValueOnGameThread();
GGameThreadMallocChurnTracker.ResetTracking();
}
GGameThreadMallocChurnTracker.ToggleTracking(true, true);
GGameThreadMallocHook = &Hook;
}
else
{
check(IsInGameThread());
GGameThreadMallocChurnTracker.ToggleTracking(false, true);
if (DumpFrame)
{
DumpFrame = 0;
GGameThreadMallocChurnTracker.ResetTracking();
}
}
}
~FScopedSampleMallocChurn()
{
if (bEnabled)
{
check(IsInGameThread());
check(GGameThreadMallocHook == &Hook);
GGameThreadMallocHook = nullptr;
GGameThreadMallocChurnTracker.ToggleTracking(false, true);
check(DumpFrame);
if (GFrameCounter > DumpFrame)
{
PrintResultsAndReset();
}
}
}
void CollectSample()
{
check(IsInGameThread());
GGameThreadMallocChurnTracker.CaptureStackTrace(CVarLogGameThreadMallocChurn_StackIgnore.GetValueOnGameThread(), nullptr, CVarLogGameThreadMallocChurn_StackLen.GetValueOnGameThread(), CVarLogGameThreadMallocChurn_RemoveAliases.GetValueOnGameThread() > 0);
}
void PrintResultsAndReset()
{
DumpFrame = GFrameCounter + CVarLogGameThreadMallocChurn_PrintFrequency.GetValueOnGameThread();
FOutputDeviceRedirector* Log = FOutputDeviceRedirector::Get();
float SampleAndFrameCorrection = float(CVarLogGameThreadMallocChurn_SampleFrequency.GetValueOnGameThread()) / float(CVarLogGameThreadMallocChurn_PrintFrequency.GetValueOnGameThread());
GGameThreadMallocChurnTracker.DumpStackTraces(CVarLogGameThreadMallocChurn_Threshhold.GetValueOnGameThread(), *Log, SampleAndFrameCorrection);
GGameThreadMallocChurnTracker.ResetTracking();
}
};
FStackTracker FScopedSampleMallocChurn::GGameThreadMallocChurnTracker;
uint64 FScopedSampleMallocChurn::DumpFrame = 0;
#endif
void FEngineLoop::Tick()
{
#if !UE_BUILD_SHIPPING && !UE_BUILD_TEST
FScopedSampleMallocChurn ChurnTracker;
#endif
// Send a heartbeat for the diagnostics thread
FThreadHeartBeat::Get().HeartBeat();
// Ensure we aren't starting a frame while loading or playing a loading movie
ensure(GetMoviePlayer()->IsLoadingFinished() && !GetMoviePlayer()->IsMovieCurrentlyPlaying());
FExternalProfiler* ActiveProfiler = FActiveExternalProfilerBase::GetActiveProfiler();
if (ActiveProfiler)
{
ActiveProfiler->FrameSync();
}
SCOPED_NAMED_EVENT(FEngineLoopTick, FColor::Red);
// early in the Tick() to get the callbacks for cvar changes called
{
QUICK_SCOPE_CYCLE_COUNTER(STAT_FEngineLoop_Tick_CallAllConsoleVariableSinks);
IConsoleManager::Get().CallAllConsoleVariableSinks();
}
{
SCOPE_CYCLE_COUNTER( STAT_FrameTime );
ENQUEUE_UNIQUE_RENDER_COMMAND(
BeginFrame,
{
GRHICommandList.LatchBypass();
GFrameNumberRenderThread++;
RHICmdList.PushEvent(*FString::Printf(TEXT("Frame%d"),GFrameNumberRenderThread), FColor(0, 255, 0, 255));
GPU_STATS_BEGINFRAME(RHICmdList);
RHICmdList.BeginFrame();
});
{
QUICK_SCOPE_CYCLE_COUNTER(STAT_FEngineLoop_FlushThreadedLogs);
// Flush debug output which has been buffered by other threads.
GLog->FlushThreadedLogs();
}
// Exit if frame limit is reached in benchmark mode.
if( (FApp::IsBenchmarking() && MaxFrameCounter && (GFrameCounter > MaxFrameCounter))
// or time limit is reached if set.
|| (MaxTickTime && (TotalTickTime > MaxTickTime)) )
{
FPlatformMisc::RequestExit(0);
}
{
QUICK_SCOPE_CYCLE_COUNTER(STAT_FEngineLoop_UpdateTimeAndHandleMaxTickRate);
// Set FApp::CurrentTime, FApp::DeltaTime and potentially wait to enforce max tick rate.
GEngine->UpdateTimeAndHandleMaxTickRate();
}
{
QUICK_SCOPE_CYCLE_COUNTER(STAT_FEngineLoop_TickFPSChart);
GEngine->TickPerformanceMonitoring( FApp::GetDeltaTime() );
}
QUICK_SCOPE_CYCLE_COUNTER(STAT_FEngineLoop_Malloc_UpdateStats);
// Update memory allocator stats.
GMalloc->UpdateStats();
}
FStats::AdvanceFrame( false, FStats::FOnAdvanceRenderingThreadStats::CreateStatic( &AdvanceRenderingThreadStatsGT ) );
{
SCOPE_CYCLE_COUNTER( STAT_FrameTime );
// Calculates average FPS/MS (outside STATS on purpose)
CalculateFPSTimings();
// Note the start of a new frame
MALLOC_PROFILER(GMalloc->Exec(nullptr, *FString::Printf(TEXT("SNAPSHOTMEMORYFRAME")),*GLog));
// handle some per-frame tasks on the rendering thread
ENQUEUE_UNIQUE_RENDER_COMMAND(
ResetDeferredUpdates,
{
FDeferredUpdateResource::ResetNeedsUpdate();
FlushPendingDeleteRHIResources_RenderThread();
});
{
SCOPE_CYCLE_COUNTER(STAT_PumpMessages);
FPlatformMisc::PumpMessages(true);
}
bool bIdleMode;
{
QUICK_SCOPE_CYCLE_COUNTER(STAT_FEngineLoop_Idle);
// Idle mode prevents ticking and rendering completely
bIdleMode = ShouldUseIdleMode();
if (bIdleMode)
{
// Yield CPU time
FPlatformProcess::Sleep(.1f);
}
}
// @todo vreditor urgent: Temporary hack to allow world-to-meters to be set before
// input is polled for motion controller devices each frame.
#if WITH_ENGINE
extern ENGINE_API float GNewWorldToMetersScale;
UWorld* HackGWorld = GWorld;
if( GNewWorldToMetersScale != 0.0f && HackGWorld != nullptr )
{
if( GNewWorldToMetersScale != HackGWorld->GetWorldSettings()->WorldToMeters )
{
HackGWorld->GetWorldSettings()->WorldToMeters = GNewWorldToMetersScale;
}
}
#endif // WITH_ENGINE
if (FSlateApplication::IsInitialized() && !bIdleMode)
{
SCOPE_TIME_GUARD(TEXT("SlateInput"));
QUICK_SCOPE_CYCLE_COUNTER(STAT_FEngineLoop_Tick_SlateInput);
FSlateApplication& SlateApp = FSlateApplication::Get();
SlateApp.PollGameDeviceState();
// Gives widgets a chance to process any accumulated input
SlateApp.FinishedInputThisFrame();
}
GEngine->Tick( FApp::GetDeltaTime(), bIdleMode );
// If a movie that is blocking the game thread has been playing,
// wait for it to finish before we continue to tick or tick again
// We do this right after GEngine->Tick() because that is where user code would initiate a load / movie.
{
QUICK_SCOPE_CYCLE_COUNTER(STAT_FEngineLoop_WaitForMovieToFinish);
GetMoviePlayer()->WaitForMovieToFinish();
}
if (GShaderCompilingManager)
{
// Process any asynchronous shader compile results that are ready, limit execution time
QUICK_SCOPE_CYCLE_COUNTER(STAT_FEngineLoop_Tick_GShaderCompilingManager);
GShaderCompilingManager->ProcessAsyncResults(true, false);
}
if (GDistanceFieldAsyncQueue)
{
QUICK_SCOPE_CYCLE_COUNTER(STAT_FEngineLoop_Tick_GDistanceFieldAsyncQueue);
GDistanceFieldAsyncQueue->ProcessAsyncTasks();
}
#if WITH_ENGINE
FGraphEventRef ConcurrentTask;
const bool bDoConcurrentSlateTick = GEngine->ShouldDoAsyncEndOfFrameTasks();
if (bDoConcurrentSlateTick)
{
const float DeltaSeconds = FApp::GetDeltaTime();
UGameViewportClient* const GameViewport = GEngine->GameViewport;
ConcurrentTask = TGraphTask<FExecuteConcurrentWithSlateTickTask>::CreateTask(nullptr, ENamedThreads::GameThread).ConstructAndDispatchWhenReady(
[GameViewport, DeltaSeconds]()
{
if (CVarDoAsyncEndOfFrameTasksRandomize.GetValueOnAnyThread(true) > 0)
{
FPlatformProcess::Sleep(FMath::RandRange(0.0f, .003f)); // this shakes up the threading to find race conditions
}
if (GameViewport != nullptr)
{
UWorld* const World = GameViewport->GetWorld();
if (World && World->DemoNetDriver)
{
World->DemoNetDriver->TickFlushAsyncEndOfFrame(DeltaSeconds);
}
}
}
);
}
#endif
if (FSlateApplication::IsInitialized() && !bIdleMode)
{
{
QUICK_SCOPE_CYCLE_COUNTER(STAT_FEngineLoop_ProcessPlayerControllersSlateOperations);
check(!IsRunningDedicatedServer());
// Process slate operations accumulated in the world ticks.
ProcessLocalPlayerSlateOperations();
}
// Tick Slate application
FSlateApplication::Get().Tick();
}
#if WITH_ENGINE
if (ConcurrentTask.GetReference())
{
QUICK_SCOPE_CYCLE_COUNTER(STAT_ConcurrentWithSlateTickTasks_Wait);
FTaskGraphInterface::Get().WaitUntilTaskCompletes(ConcurrentTask);
ConcurrentTask = nullptr;
}
#endif
#if STATS
// Clear any stat group notifications we have pending just incase they weren't claimed during FSlateApplication::Get().Tick
extern CORE_API void ClearPendingStatGroups();
ClearPendingStatGroups();
#endif
#if WITH_EDITOR
{
QUICK_SCOPE_CYCLE_COUNTER( STAT_FEngineLoop_Tick_AutomationController );
static FName AutomationController( "AutomationController" );
//Check if module loaded to support the change to allow this to be hot compilable.
if (FModuleManager::Get().IsModuleLoaded( AutomationController ))
{
FModuleManager::GetModuleChecked<IAutomationControllerModule>( AutomationController ).Tick();
}
}
#endif
#if WITH_ENGINE
#if WITH_AUTOMATION_WORKER
{
QUICK_SCOPE_CYCLE_COUNTER(STAT_FEngineLoop_Tick_AutomationWorker);
//Check if module loaded to support the change to allow this to be hot compilable.
static const FName AutomationWorkerModuleName = TEXT("AutomationWorker");
if (FModuleManager::Get().IsModuleLoaded(AutomationWorkerModuleName))
{
FModuleManager::GetModuleChecked<IAutomationWorkerModule>(AutomationWorkerModuleName).Tick();
}
}
#endif
#endif //WITH_ENGINE
{
SCOPE_CYCLE_COUNTER(STAT_RHITickTime);
RHITick( FApp::GetDeltaTime() ); // Update RHI.
}
// Increment global frame counter. Once for each engine tick.
GFrameCounter++;
// Disregard first few ticks for total tick time as it includes loading and such.
if( GFrameCounter > 6 )
{
TotalTickTime+=FApp::GetDeltaTime();
}
// Find the objects which need to be cleaned up the next frame.
FPendingCleanupObjects* PreviousPendingCleanupObjects = PendingCleanupObjects;
PendingCleanupObjects = GetPendingCleanupObjects();
{
SCOPE_CYCLE_COUNTER( STAT_FrameSyncTime );
// this could be perhaps moved down to get greater parallelizm
// Sync game and render thread. Either total sync or allowing one frame lag.
static FFrameEndSync FrameEndSync;
static auto CVarAllowOneFrameThreadLag = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.OneFrameThreadLag"));
FrameEndSync.Sync( CVarAllowOneFrameThreadLag->GetValueOnGameThread() != 0 );
}
{
SCOPE_CYCLE_COUNTER( STAT_DeferredTickTime );
// Delete the objects which were enqueued for deferred cleanup before the previous frame.
delete PreviousPendingCleanupObjects;
// Destroy all linkers pending delete
#if WITH_COREUOBJECT
DeleteLoaders();
#endif
FTicker::GetCoreTicker().Tick(FApp::GetDeltaTime());
FThreadManager::Get().Tick();
GEngine->TickDeferredCommands();
}
ENQUEUE_UNIQUE_RENDER_COMMAND(
EndFrame,
{
RHICmdList.EndFrame();
GPU_STATS_ENDFRAME(RHICmdList);
RHICmdList.PopEvent();
});
// Set CPU utilization stats.
const FCPUTime CPUTime = FPlatformTime::GetCPUTime();
SET_FLOAT_STAT( STAT_CPUTimePct, CPUTime.CPUTimePct );
SET_FLOAT_STAT( STAT_CPUTimePctRelative, CPUTime.CPUTimePctRelative );
// Set the UObject count stat
#if UE_GC_TRACK_OBJ_AVAILABLE
SET_DWORD_STAT(STAT_Hash_NumObjects, GUObjectArray.GetObjectArrayNumMinusAvailable());
#endif
}
}
void FEngineLoop::ClearPendingCleanupObjects()
{
delete PendingCleanupObjects;
PendingCleanupObjects = nullptr;
}
#endif // WITH_ENGINE
static TAutoConsoleVariable<int32> CVarLogTimestamp(
TEXT("log.Timestamp"),
1,
TEXT("Defines if time is included in each line in the log file and in what form. Layout: [time][frame mod 1000]\n")
TEXT(" 0 = Do not display log timestamps\n")
TEXT(" 1 = Log time stamps in UTC and Frametime (default) e.g. [2015.11.25-21.28.50:803][376]\n")
TEXT(" 2 = Log timestamps in seconds elapsed since GStartTime e.g. [0130.29][420]"),
ECVF_Default);
static TAutoConsoleVariable<int32> CVarLogCategory(
TEXT("log.Category"),
1,
TEXT("Defines if the categoy is included in each line in the log file and in what form.\n")
TEXT(" 0 = Do not log category\n")
TEXT(" 2 = Log the category (default)"),
ECVF_Default);
// Gets called any time cvars change (on the main thread)
static void CVarLogSinkFunction()
{
{
// for debugging
ELogTimes::Type OldGPrintLogTimes = GPrintLogTimes;
int32 LogTimestampValue = CVarLogTimestamp.GetValueOnGameThread();
// Note GPrintLogTimes can be used on multiple threads but it should be no issue to change it on the fly
switch(LogTimestampValue)
{
default:
case 0: GPrintLogTimes = ELogTimes::None; break;
case 1: GPrintLogTimes = ELogTimes::UTC; break;
case 2: GPrintLogTimes = ELogTimes::SinceGStartTime; break;
}
}
{
int32 LogCategoryValue = CVarLogCategory.GetValueOnGameThread();
// Note GPrintLogCategory can be used on multiple threads but it should be no issue to change it on the fly
GPrintLogCategory = LogCategoryValue != 0;
}
}
FAutoConsoleVariableSink CVarLogSink(FConsoleCommandDelegate::CreateStatic(&CVarLogSinkFunction));
static void CheckForPrintTimesOverride()
{
// Determine whether to override the default setting for including timestamps in the log.
FString LogTimes;
if (GConfig->GetString( TEXT( "LogFiles" ), TEXT( "LogTimes" ), LogTimes, GEngineIni ))
{
if (LogTimes == TEXT( "SinceStart" ))
{
CVarLogTimestamp->Set(2, ECVF_SetBySystemSettingsIni);
}
// Assume this is a bool for backward compatibility
else if (FCString::ToBool( *LogTimes ))
{
CVarLogTimestamp->Set(1, ECVF_SetBySystemSettingsIni);
}
}
if (FParse::Param( FCommandLine::Get(), TEXT( "LOGTIMES" ) ))
{
CVarLogTimestamp->Set(1, ECVF_SetByCommandline);
}
else if (FParse::Param( FCommandLine::Get(), TEXT( "NOLOGTIMES" ) ))
{
CVarLogTimestamp->Set(0, ECVF_SetByCommandline);
}
else if (FParse::Param( FCommandLine::Get(), TEXT( "LOGTIMESINCESTART" ) ))
{
CVarLogTimestamp->Set(2, ECVF_SetByCommandline);
}
}
/* FEngineLoop static interface
*****************************************************************************/
bool FEngineLoop::AppInit( )
{
// Output devices.
GError = FPlatformOutputDevices::GetError();
GWarn = FPlatformOutputDevices::GetWarn();
BeginInitTextLocalization();
// Avoiding potential exploits by not exposing command line overrides in the shipping games.
#if !UE_BUILD_SHIPPING && WITH_EDITORONLY_DATA
// 8192 is the maximum length of the command line on Windows XP.
TCHAR CmdLineEnv[8192];
// Retrieve additional command line arguments from environment variable.
FPlatformMisc::GetEnvironmentVariable(TEXT("UE-CmdLineArgs"), CmdLineEnv,ARRAY_COUNT(CmdLineEnv));
// Manually nullptr terminate just in case. The nullptr string is returned above in the error case so
// we don't have to worry about that.
CmdLineEnv[ARRAY_COUNT(CmdLineEnv)-1] = 0;
FString Env = FString(CmdLineEnv).Trim();
if (Env.Len())
{
// Append the command line environment after inserting a space as we can't set it in the
// environment. Note that any code accessing GCmdLine before appInit obviously won't
// respect the command line environment additions.
FCommandLine::Append(TEXT(" -EnvAfterHere "));
FCommandLine::Append(CmdLineEnv);
}
#endif
// Error history.
FCString::Strcpy(GErrorHist, TEXT("Fatal error!" LINE_TERMINATOR LINE_TERMINATOR));
// Platform specific pre-init.
FPlatformMisc::PlatformPreInit();
// Keep track of start time.
GSystemStartTime = FDateTime::Now().ToString();
// Switch into executable's directory.
FPlatformProcess::SetCurrentWorkingDirectoryToBaseDir();
// Now finish initializing the file manager after the command line is set up
IFileManager::Get().ProcessCommandLineOptions();
FPageAllocator::LatchProtectedMode();
if (FParse::Param(FCommandLine::Get(), TEXT("purgatorymallocproxy")))
{
FMemory::EnablePurgatoryTests();
}
if (FParse::Param(FCommandLine::Get(), TEXT("poisonmallocproxy")))
{
FMemory::EnablePoisonTests();
}
#if !UE_BUILD_SHIPPING
if (FParse::Param(FCommandLine::Get(), TEXT("BUILDMACHINE")))
{
GIsBuildMachine = true;
}
// If "-WaitForDebugger" was specified, halt startup and wait for a debugger to attach before continuing
if( FParse::Param( FCommandLine::Get(), TEXT( "WaitForDebugger" ) ) )
{
while( !FPlatformMisc::IsDebuggerPresent() )
{
FPlatformProcess::Sleep( 0.1f );
}
}
#endif // !UE_BUILD_SHIPPING
#if PLATFORM_WINDOWS
// make sure that the log directory exists
IFileManager::Get().MakeDirectory( *FPaths::GameLogDir() );
// update the mini dump filename now that we have enough info to point it to the log folder even in installed builds
FCString::Strcpy(MiniDumpFilenameW, *IFileManager::Get().ConvertToAbsolutePathForExternalAppForWrite(*FString::Printf(TEXT("%sunreal-v%i-%s.dmp"), *FPaths::GameLogDir(), FEngineVersion::Current().GetChangelist(), *FDateTime::Now().ToString())));
#endif
// Init logging to disk
FPlatformOutputDevices::SetupOutputDevices();
// init config system
FConfigCacheIni::InitializeConfigSystem();
// Now that configs have been initialized, setup stack walking options
FPlatformStackWalk::Init();
CheckForPrintTimesOverride();
// Check whether the project or any of its plugins are missing or are out of date
#if UE_EDITOR && !IS_MONOLITHIC
if(!GIsBuildMachine && FPaths::IsProjectFilePathSet() && IPluginManager::Get().AreRequiredPluginsAvailable())
{
const FProjectDescriptor* CurrentProject = IProjectManager::Get().GetCurrentProject();
if(CurrentProject != nullptr && CurrentProject->Modules.Num() > 0)
{
bool bNeedCompile = false;
GConfig->GetBool(TEXT("/Script/UnrealEd.EditorLoadingSavingSettings"), TEXT("bForceCompilationAtStartup"), bNeedCompile, GEditorPerProjectIni);
if(FParse::Param(FCommandLine::Get(), TEXT("SKIPCOMPILE")) || FParse::Param(FCommandLine::Get(), TEXT("MULTIPROCESS")))
{
bNeedCompile = false;
}
if(!bNeedCompile)
{
// Check if any of the project or plugin modules are out of date, and the user wants to compile them.
TArray<FString> IncompatibleFiles;
IProjectManager::Get().CheckModuleCompatibility(IncompatibleFiles);
IPluginManager::Get().CheckModuleCompatibility(IncompatibleFiles);
if (IncompatibleFiles.Num() > 0)
{
// Log the modules which need to be rebuilt
FString ModulesList = TEXT("The following modules are missing or built with a different engine version:\n\n");
for (int Idx = 0; Idx < IncompatibleFiles.Num(); Idx++)
{
UE_LOG(LogInit, Warning, TEXT("Incompatible or missing module: %s"), *IncompatibleFiles[Idx]);
ModulesList += IncompatibleFiles[Idx] + TEXT("\n");
}
ModulesList += TEXT("\nWould you like to rebuild them now?");
// If we're running with -stdout, assume that we're a non interactive process and about to fail
if (FApp::IsUnattended() || FParse::Param(FCommandLine::Get(), TEXT("stdout")))
{
return false;
}
// Ask whether to compile before continuing
if (FPlatformMisc::MessageBoxExt(EAppMsgType::YesNo, *ModulesList, *FString::Printf(TEXT("Missing %s Modules"), FApp::GetGameName())) == EAppReturnType::No)
{
return false;
}
bNeedCompile = true;
}
}
if(bNeedCompile)
{
// Try to compile it
FFeedbackContext *Context = (FFeedbackContext*)FDesktopPlatformModule::Get()->GetNativeFeedbackContext();
Context->BeginSlowTask(FText::FromString(TEXT("Starting build...")), true, true);
bool bCompileResult = FDesktopPlatformModule::Get()->CompileGameProject(FPaths::RootDir(), FPaths::GetProjectFilePath(), Context);
Context->EndSlowTask();
// Get a list of modules which are still incompatible
TArray<FString> StillIncompatibleFiles;
IProjectManager::Get().CheckModuleCompatibility(StillIncompatibleFiles);
IPluginManager::Get().CheckModuleCompatibility(StillIncompatibleFiles);
if(!bCompileResult || StillIncompatibleFiles.Num() > 0)
{
for (int Idx = 0; Idx < StillIncompatibleFiles.Num(); Idx++)
{
UE_LOG(LogInit, Warning, TEXT("Still incompatible or missing module: %s"), *StillIncompatibleFiles[Idx]);
}
if (!FApp::IsUnattended())
{
FPlatformMisc::MessageBoxExt(EAppMsgType::Ok, *FString::Printf(TEXT("%s could not be compiled. Try rebuilding from source manually."), FApp::GetGameName()), TEXT("Error"));
}
return false;
}
}
}
}
#endif
// NOTE: This is the earliest place to init the online subsystems (via plugins)
// Code needs GConfigFile to be valid
// Must be after FThreadStats::StartThread();
// Must be before Render/RHI subsystem D3DCreate()
// For platform services that need D3D hooks like Steam
// Load "pre-init" plugin modules
if (!IProjectManager::Get().LoadModulesForProject(ELoadingPhase::PostConfigInit) || !IPluginManager::Get().LoadModulesForEnabledPlugins(ELoadingPhase::PostConfigInit))
{
return false;
}
// Register the callback that allows the text localization manager to load data for plugins
FTextLocalizationManager::Get().GatherAdditionalLocResPathsCallback.AddLambda([](TArray<FString>& OutLocResPaths)
{
IPluginManager::Get().GetLocalizationPathsForEnabledPlugins(OutLocResPaths);
});
PreInitHMDDevice();
// Put the command line and config info into the suppression system
FLogSuppressionInterface::Get().ProcessConfigAndCommandLine();
// after the above has run we now have the REQUIRED set of engine .INIs (all of the other .INIs)
// that are gotten from .h files' config() are not requires and are dynamically loaded when the .u files are loaded
#if !UE_BUILD_SHIPPING
// Prompt the user for remote debugging?
bool bPromptForRemoteDebug = false;
GConfig->GetBool(TEXT("Engine.ErrorHandling"), TEXT("bPromptForRemoteDebugging"), bPromptForRemoteDebug, GEngineIni);
bool bPromptForRemoteDebugOnEnsure = false;
GConfig->GetBool(TEXT("Engine.ErrorHandling"), TEXT("bPromptForRemoteDebugOnEnsure"), bPromptForRemoteDebugOnEnsure, GEngineIni);
if (FParse::Param(FCommandLine::Get(), TEXT("PROMPTREMOTEDEBUG")))
{
bPromptForRemoteDebug = true;
}
if (FParse::Param(FCommandLine::Get(), TEXT("PROMPTREMOTEDEBUGENSURE")))
{
bPromptForRemoteDebug = true;
bPromptForRemoteDebugOnEnsure = true;
}
FPlatformMisc::SetShouldPromptForRemoteDebugging(bPromptForRemoteDebug);
FPlatformMisc::SetShouldPromptForRemoteDebugOnEnsure(bPromptForRemoteDebugOnEnsure);
// Feedback context.
if (FParse::Param(FCommandLine::Get(), TEXT("WARNINGSASERRORS")))
{
GWarn->TreatWarningsAsErrors = true;
}
if (FParse::Param(FCommandLine::Get(), TEXT("SILENT")))
{
GIsSilent = true;
}
#endif // !UE_BUILD_SHIPPING
// Show log if wanted.
if (GLogConsole && FParse::Param(FCommandLine::Get(), TEXT("LOG")))
{
GLogConsole->Show(true);
}
//// Command line.
UE_LOG(LogInit, Log, TEXT("Build: %s"), FApp::GetBuildVersion());
UE_LOG(LogInit, Log, TEXT("Engine Version: %s"), *FEngineVersion::Current().ToString());
UE_LOG(LogInit, Log, TEXT("Compatible Engine Version: %s"), *FEngineVersion::CompatibleWith().ToString());
UE_LOG(LogInit, Log, TEXT("Net CL: %u"), FNetworkVersion::GetNetworkCompatibleChangelist());
FDevVersionRegistration::DumpVersionsToLog();
#if PLATFORM_64BITS
UE_LOG(LogInit, Log, TEXT("Compiled (64-bit): %s %s"), ANSI_TO_TCHAR(__DATE__), ANSI_TO_TCHAR(__TIME__));
#else
UE_LOG(LogInit, Log, TEXT("Compiled (32-bit): %s %s"), ANSI_TO_TCHAR(__DATE__), ANSI_TO_TCHAR(__TIME__));
#endif
// Print compiler version info
#if defined(__clang__)
UE_LOG(LogInit, Log, TEXT("Compiled with Clang: %s"), ANSI_TO_TCHAR( __clang_version__ ) );
#elif defined(__INTEL_COMPILER)
UE_LOG(LogInit, Log, TEXT("Compiled with ICL: %d"), __INTEL_COMPILER);
#elif defined( _MSC_VER )
#ifndef __INTELLISENSE__ // Intellisense compiler doesn't support _MSC_FULL_VER
{
const FString VisualCPPVersion( FString::Printf( TEXT( "%d" ), _MSC_FULL_VER ) );
const FString VisualCPPRevisionNumber( FString::Printf( TEXT( "%02d" ), _MSC_BUILD ) );
UE_LOG(LogInit, Log, TEXT("Compiled with Visual C++: %s.%s.%s.%s"),
*VisualCPPVersion.Mid( 0, 2 ), // Major version
*VisualCPPVersion.Mid( 2, 2 ), // Minor version
*VisualCPPVersion.Mid( 4 ), // Build version
*VisualCPPRevisionNumber // Revision number
);
}
#endif
#else
UE_LOG(LogInit, Log, TEXT("Compiled with unrecognized C++ compiler") );
#endif
UE_LOG(LogInit, Log, TEXT("Build Configuration: %s"), EBuildConfigurations::ToString(FApp::GetBuildConfiguration()));
UE_LOG(LogInit, Log, TEXT("Branch Name: %s"), *FApp::GetBranchName() );
UE_LOG(LogInit, Log, TEXT("Command line: %s"), FCommandLine::GetForLogging() );
UE_LOG(LogInit, Log, TEXT("Base directory: %s"), FPlatformProcess::BaseDir() );
//UE_LOG(LogInit, Log, TEXT("Character set: %s"), sizeof(TCHAR)==1 ? TEXT("ANSI") : TEXT("Unicode") );
UE_LOG(LogInit, Log, TEXT("Installed Engine Build: %d"), FApp::IsEngineInstalled() ? 1 : 0);
// if a logging build, clear out old log files
#if !NO_LOGGING
FMaintenance::DeleteOldLogs();
#endif
#if !UE_BUILD_SHIPPING
FApp::InitializeSession();
#endif
// Checks.
check(sizeof(uint8) == 1);
check(sizeof(int8) == 1);
check(sizeof(uint16) == 2);
check(sizeof(uint32) == 4);
check(sizeof(uint64) == 8);
check(sizeof(ANSICHAR) == 1);
#if PLATFORM_TCHAR_IS_4_BYTES
check(sizeof(TCHAR) == 4);
#else
check(sizeof(TCHAR) == 2);
#endif
check(sizeof(int16) == 2);
check(sizeof(int32) == 4);
check(sizeof(int64) == 8);
check(sizeof(bool) == 1);
check(sizeof(float) == 4);
check(sizeof(double) == 8);
// Init list of common colors.
GColorList.CreateColorMap();
bool bForceSmokeTests = false;
GConfig->GetBool(TEXT("AutomationTesting"), TEXT("bForceSmokeTests"), bForceSmokeTests, GEngineIni);
bForceSmokeTests |= FParse::Param(FCommandLine::Get(), TEXT("bForceSmokeTests"));
FAutomationTestFramework::Get().SetForceSmokeTests(bForceSmokeTests);
// Init other systems.
FCoreDelegates::OnInit.Broadcast();
return true;
}
void FEngineLoop::AppPreExit( )
{
UE_LOG(LogExit, Log, TEXT("Preparing to exit.") );
FCoreDelegates::OnPreExit.Broadcast();
MALLOC_PROFILER( GMalloc->Exec(nullptr, TEXT("MPROF STOP"), *GLog); );
#if WITH_ENGINE
if (FString(FCommandLine::Get()).Contains(TEXT("CreatePak")) && GetDerivedDataCache())
{
// if we are creating a Pak, we need to make sure everything is done and written before we exit
UE_LOG(LogInit, Display, TEXT("Closing DDC Pak File."));
GetDerivedDataCacheRef().WaitForQuiescence(true);
}
#endif
#if WITH_EDITOR
FRemoteConfig::Flush();
#endif
FCoreDelegates::OnExit.Broadcast();
// Clean up the thread pool
if (GThreadPool != nullptr)
{
GThreadPool->Destroy();
}
if (GIOThreadPool != nullptr)
{
GIOThreadPool->Destroy();
}
#if WITH_ENGINE
if ( GShaderCompilingManager )
{
GShaderCompilingManager->Shutdown();
delete GShaderCompilingManager;
GShaderCompilingManager = nullptr;
}
#endif
}
void FEngineLoop::AppExit( )
{
UE_LOG(LogExit, Log, TEXT("Exiting."));
FPlatformMisc::PlatformTearDown();
if (GConfig)
{
GConfig->Exit();
delete GConfig;
GConfig = nullptr;
}
if( GLog )
{
GLog->TearDown();
}
FInternationalization::TearDown();
}
void FEngineLoop::PreInitHMDDevice()
{
#if WITH_ENGINE && !UE_SERVER
if (!FParse::Param(FCommandLine::Get(), TEXT("nohmd")) && !FParse::Param(FCommandLine::Get(), TEXT("emulatestereo")))
{
// Get a list of modules that implement this feature
FName Type = IHeadMountedDisplayModule::GetModularFeatureName();
IModularFeatures& ModularFeatures = IModularFeatures::Get();
TArray<IHeadMountedDisplayModule*> HMDModules = ModularFeatures.GetModularFeatureImplementations<IHeadMountedDisplayModule>(Type);
// Iterate over modules, calling PreInit
for (auto HMDModuleIt = HMDModules.CreateIterator(); HMDModuleIt; ++HMDModuleIt)
{
IHeadMountedDisplayModule* HMDModule = *HMDModuleIt;
if (!HMDModule->PreInit())
{
// Unregister modules which fail PreInit
ModularFeatures.UnregisterModularFeature(Type, HMDModule);
}
}
}
#endif // #if WITH_ENGINE && !UE_SERVER
}
#undef LOCTEXT_NAMESPACE
Reference in New Issue View Git Blame Copy Permalink