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
368bd22e6bdcddf910a650822019af668559af73
UnrealEngineUWP/Engine/Source/Runtime/Launch/Private/LaunchEngineLoop.cpp
Ori Cohen 368bd22e6b Copying //UE4/Dev-Framework to //UE4/Dev-Main (Source: //UE4/Dev-Framework @ 3153514) 
#lockdown Nick.Penwarden
#rb none

==========================
MAJOR FEATURES + CHANGES
==========================

Change 3050254 on 2016/07/14 by Marc.Audy

	Merging //UE4/Dev-Main to Dev-Framework (//UE4/Dev-Framework) @ 3049614

Change 3136629 on 2016/09/22 by Marc.Audy

	bye bye auto

Change 3136631 on 2016/09/22 by Marc.Audy

	Allow objects to be marked as duplicate transient or non PIE duplicate transient
	ChildActors are not marked consistent with the property that references them as text export transient and non PIE duplicate transient
	#jira UE-35680

Change 3136636 on 2016/09/22 by Marc.Audy

	ParticleSystem and Audio Components now  route Activate/Deactivate events to blueprints
	Component Activate/Deactivate events now provide component as a property
	#jira UE-35191

Change 3136640 on 2016/09/22 by Marc.Audy

	Expose bReplicates to blueprint component properties
	#jira UE-34433

Change 3136709 on 2016/09/22 by Ori.Cohen

	Fix GetBodyInstance returning incorrect bodies when welded kinematics are attached.

	#JIRA UE-36234

Change 3136710 on 2016/09/22 by Ori.Cohen

	Fix defer actors not working when the physics scene is simulating. We now flush when the scene is not simulating, as well as a lazy flush that goes through the slow path when needed. This allows us to batch multiple components together.

	#JIRA UE-35899

Change 3136770 on 2016/09/22 by Marc.Audy

	Fix compile error

Change 3136854 on 2016/09/22 by Marc.Audy

	Sprite components need to be text export transient
	#jira UE-36064

Change 3136926 on 2016/09/22 by Ori.Cohen

	Fix ensure when skeletal mesh bodies have no collision.

Change 3137054 on 2016/09/22 by Aaron.McLeran

	PR #2628: Fix UAudioComponent SubtitlePriority not being initialised (Contributed by alanedwardes)

Change 3137058 on 2016/09/22 by Aaron.McLeran

	PR #2562: ReadCompressedInfo calculates duration for ADPCM audio (Contributed by derekvanvliet)

Change 3137060 on 2016/09/22 by Aaron.McLeran

	UE-36336 Fixing A3D for mono/2D sounds

	- Making it so if A3D is being loaded but not enabled, we can not have reverb on 2D sounds
	- Fixing A3D mono sources from failing after a time

Change 3137066 on 2016/09/22 by Aaron.McLeran

	Checking in Ngs2.Build.cs with A3D and USING_A3D set to 0

Change 3137098 on 2016/09/22 by dan.reynolds

	AEOverview Update: EQ Map, Reverb Map plus improvements on Main array cleanup process.

Change 3137132 on 2016/09/22 by Aaron.McLeran

	PR #2789: Fixed signature of FActiveSound::GetIntParameter (Contributed by Laurie-Hedge)

Change 3137175 on 2016/09/22 by Aaron.McLeran

	Fixing compile error with PhysXCollision.cpp from CL 3136710

Change 3137540 on 2016/09/23 by Thomas.Sarkanen

	Fixed crash when generating LODs automatically for skeletal meshes

	Quadric error reduction does not support skeletal meshes, so fails. Client code assumes that it cannot fail so crashed. This guards against immediatly assuming that LODs are valid after simplification.

	#jira UE-36253 - Crash applying LOD changes in Persona

Change 3137720 on 2016/09/23 by Thomas.Sarkanen

	Changed asset shortcut bar to display asset names & reworked padding

	#jira UE-36347 - Anim asset shortcut bar has difficult to read/cut-off text

Change 3137761 on 2016/09/23 by Martin.Wilson

	Fix typo in root motion from everything accumulation code

Change 3137877 on 2016/09/23 by Thomas.Sarkanen

	Fixed undo/redo forcing skeletal meshes into t-pose

	Re-populated AnimationData in InitAnim for UDebugSkelMeshComponent.

	#jira UE-35579 - If you undo an animation change to any animation asset (for single preview), the playback controls will no longer function

Change 3137885 on 2016/09/23 by Benn.Gallagher

	Fixed APEX clothing disappearing when time dilation results in a dt of 0. After simulating an actor with 0 APEX will fill positions and normals with NaNs, causing the disappearance. The fix in this case is to not schedule the evaluation task if we're not wanting to do any work. The simulation then freezes as we would expect.
	#jira UE-35151

Change 3137888 on 2016/09/23 by Benn.Gallagher

	Fixed transition nodes being able to be pasted or duplicated without 2 valid pin links
	#jira UE-24860

Change 3137889 on 2016/09/23 by Benn.Gallagher

	Fixed transform and widget inconsistencies in IK edit mode
	#jira UE-20628

Change 3137890 on 2016/09/23 by Jurre.deBaare

	Alembic Cached Geometry Does Not Display in Stand Alone Game
	#fix required to force load the GeometryCache module during runtime
	#jira UE-36187

Change 3137892 on 2016/09/23 by Jurre.deBaare

	Geometry cache playback should work in sequencer
	#fix add Interp UProperty tag to specific properties used for playing back the cache, future fix is having same approach as skeletal mesh animation for sequencer (depends on needs, -> skeletal mesh import has better compression anyway)
	#jira UE-35447

Change 3137893 on 2016/09/23 by Jurre.deBaare

	Alembic Cache Importer option for Hard Edge Angle Threshold does not work for objects with no normals
	#fix adhere to the assumed 'standard' no normals in ABC file means completely smooth normals throughout the sequence
	#jira UE-35091

Change 3137894 on 2016/09/23 by Jurre.deBaare

	Importing an Alembic File While mesh Distance Fields are Enabled Crashes Editor
	#fix Needed to save the raw mesh before building the mesh to ensure a LOD resource was created
	#misc added a new check + message in case this occurs again
	#jira UE-36059

Change 3137938 on 2016/09/23 by Jurre.deBaare

	Alembic Importing with Incorrect UV's
	#fix adding option for flipping UVs on import
	#jira UE-36190

	Alembic import axis not aligned correctly
	#fix also added option to specify scale and rotation to be applied during import (with preset for Maya and Max)
	#jira UE-35510

Change 3137949 on 2016/09/23 by Jurre.deBaare

	Frame range importing causes confusion during Alembic importing
	#fix this required storing information per Alembic object at which frame index it actual has stored frames, using this data we can determine which frames are empty, and at which frame there is data. This allows us to skip empty frames if we want to import data-only frames, or to import all frames in the sequence including empty (pre-roll) frames.
	#misc changed settings UI listview layout (extra columns and resized old ones)
	#jira UE-35498

Change 3137994 on 2016/09/23 by Martin.Wilson

	Fix for creating an empty state when dragging a montage into a state machine graph

	#jira UE-33371

Change 3138103 on 2016/09/23 by Aaron.McLeran

	UE-36312 Fixing sound node distance cross fade for case of looping sounds

Change 3138104 on 2016/09/23 by Aaron.McLeran

	UE-35392 Copy pasting local node into separate project crashes the engine

Change 3138224 on 2016/09/23 by Aaron.McLeran

	UE-36312 Fixing sound node distance cross fade for case of looping sounds

	- Adding a check for wave instance count to account for virtualized sounds (one-shots)

Change 3138666 on 2016/09/23 by Ben.Zeigler

	#UEFW-204 Add more comprehensive gameplay tag tests
	Fix issue with HasTag(Tag, IncludeParent, IncludeParent) revealed by tests, this was not returning true correctly in some cases. This use case is weird and will be deprecated soon

Change 3138779 on 2016/09/23 by Marc.Audy

	Get rid of pointless casts

Change 3138782 on 2016/09/23 by Marc.Audy

	remove some GWorlds

Change 3139701 on 2016/09/26 by Jurre.deBaare

	Assert failed on GemetryCache for PS4 package
	#fix add GeometryCache reference in engine build.cs and fix the serialization of geometry cache files
	#jira UE-36392

Change 3139704 on 2016/09/26 by Jurre.deBaare

	Fix for -1 begin frame
	#fix do the max as an signed int, to make sure we don't wrap around

Change 3139748 on 2016/09/26 by Benn.Gallagher

	PR #2784: Make sure that SceneScratchBufferSize is a multiple of 16K as requested by PhysX (Contributed by DenizPiri)

	Moved the definition of the boundary to a FPhysScene class static
	Changed comments on original user settings property to communicate the fact that the value is now rounded to the next 16K boundary

	#jira UE-35736

Change 3139903 on 2016/09/26 by Benn.Gallagher

	Fixed exposing subinstance pins stomping over class defaults and setting to uninitialized values
	#jira UE-34366

Change 3140409 on 2016/09/26 by Lukasz.Furman

	fixed uninitialized configs of gameplay debugger
	copy of CL# 3140399

Change 3140516 on 2016/09/26 by dan.reynolds

	AEOverview Map Update - Ambient Zone + Focus Test

Change 3140526 on 2016/09/26 by Jon.Nabozny

	#rn Fixed CanJump inconsistencies with previous versions.

	Deferred JumpCurrentCount increment until after jump, made bWasJumping a member variable, and updated how
	jump count and hold time were compared in CanJump.

	#jira UE-35524, UE-35582

Change 3140745 on 2016/09/26 by dan.reynolds

	AEOverview Test Map Update + Occlusion Test

Change 3140839 on 2016/09/26 by dan.reynolds

	AEOverview - minor updates

Change 3141101 on 2016/09/27 by Thomas.Sarkanen

	Preview scene worlds now render correctly

	Split "Preview" type into "EditorPreview" (the default) and "GamePreview". Deprecated the old "Preview" world type (but kept its index).
	In-game hidden flags now apply to GamePreview, but not EditorPreview worlds.
	Deprecated old bHack_Force_UsesGameHiddenFlags_True boolean. GamePReview now serves this purpose.
	Fixed up UT cases where this was being used.
	FPreviewScenes now use the editor mode by default, but can be set to non-editor if needed (as is the case with the still-experimental UViewport).
	Custom depth pass is not enabled for EditorPreview (as before) but is for GamePreview.
	Fixed erroneous use of TEnumAsByte for non-uproperty WorldType.

	#jira UE-22883 - Using FPreviewScenes in-game for scene captures

Change 3141106 on 2016/09/27 by Thomas.Sarkanen

	Column toggling improvements

	Column toggle menu now does not close when items are selected.
	This requries some Slate changes to how submenus are built to allow for sumbenus to specify whether they close after selection.
	Also allowed columns to be hidden by default for specific use cases (like the sequence browser).

	#jira UE-35818 - Anim asset browser column picker should stay up

Change 3141131 on 2016/09/27 by Thomas.Sarkanen

	Fix CIS warnings

	Fallout from preview world changes

Change 3141143 on 2016/09/27 by Jurre.deBaare

	Fix for CIS errors

Change 3141235 on 2016/09/27 by Thomas.Sarkanen

	Fix offset of Persona floor mesh when auto-alignment is enabled

	When auto alignment was disabled, the offset wasnt getting taken into account.

	#jira UE-35544 - In Persona, Floor Height Offset does nothing with Auto Align Floor to Mesh disabled

Change 3141327 on 2016/09/27 by Marc.Audy

	Ensure that the client side AttachChildren array remains accurate
	#jira UE-26025

Change 3141474 on 2016/09/27 by mason.seay

	Updating test map name and moving PlayerStart

Change 3141501 on 2016/09/27 by Benn.Gallagher

	Loading time improvements for destructibles from Nvidia
	Updated to use new framework custom version instead of global object version
	Fixed usage of TArray to enable correct loading and saving of the cached data.
	#jira UE-29680

Change 3141889 on 2016/09/27 by Marc.Audy

	Fix DestructibleMesh when WITH_APEX is 0
	#jira UE-36484

Change 3142034 on 2016/09/27 by Marc.Audy

	Merging //UE4/Dev-Main to Dev-Framework (//UE4/Dev-Framework) @ 3141971

Change 3142131 on 2016/09/27 by Ori.Cohen

	Make sure we return eTouch to physx during an overlap query. Fixes bad behavior when multiple objects blocked in an overlap query.

	#JIRA UE-36381

Change 3142154 on 2016/09/27 by Ori.Cohen

	Fix build, ModuleCachedData instead of NxApexModuleCachedData

Change 3142159 on 2016/09/27 by mason.seay

	Blueprint for testing Child Actor Templates

Change 3142255 on 2016/09/27 by Jon.Nabozny

	Fix crashes in QAMeshMerge component by making it a UObject, exposing it's method statically, and taking QASkeletalMeshMergeParams as an argument.

	#jira UE-35199, UE-35197, UE-35201

Change 3142717 on 2016/09/27 by dan.reynolds

	AEOverview Update + Sound Class Test

Change 3142764 on 2016/09/27 by Marc.Audy

	Fix Ocean deprecation warnings

Change 3142962 on 2016/09/28 by Thomas.Sarkanen

	Fixed bounds calculations for local camera animations

	Correctly calculated bounds as local to the initial transform in the track.
	Implemented suggested fixes from UDN user chhaddon (The Coalition).

	#jira UE-29594 - CameraAnim bounds are incorrect when bRelativeToInitialTransform == true

Change 3143007 on 2016/09/28 by Martin.Wilson

	Added virtual bones to USkeleton

	API Breaking change:
	-Added USkeleton pointer to RemoveBonesByName
	-FReferenceSkeleton::UpdateRefPoseTransform & FReferenceSkeleton::Add made private. Must use FReferenceSkeletonModifier instead

	#jira UEFW-81

Change 3143040 on 2016/09/28 by James.Golding

	Strip DrawDebug.. functions from Shipping and Test builds, controlled by new define ENABLE_DRAW_DEBUG
	Fix up game projects to compile in Shipping/Test after this change

	PR #2757: (Contributed by projectgheist)
	#jira UE-35488

Change 3143046 on 2016/09/28 by James.Golding

	Fix OrionEnvironmentPerfTest.cpp compiling in Shipping (optimizations were not being re-enabled at end of file)

Change 3143047 on 2016/09/28 by James.Golding

	PR #2731: Capsule primitive drawing fix (Contributed by kamrann)
	#jira UE-35142

Change 3143050 on 2016/09/28 by Martin.Wilson

	Update DDC key as some animation have stale data

Change 3143088 on 2016/09/28 by Martin.Wilson

	CIS Fixes for Ocean after FReferenceSkeleton changes

Change 3143090 on 2016/09/28 by Benn.Gallagher

	Fixed split pins in animation blueprints losing their pin links on editor restart. The anim nodes had opted out of the Super version of reconstruct, but that's where split pin restoration was added so we were skipping it.
	#jira UE-36482

Change 3143091 on 2016/09/28 by Thomas.Sarkanen

	Fix play/pause keyboard shortcut toggle in Persona based editors

	Correctly handled widget mode switching in the skeleton selection edit mode (previously it was manually handling this rather than hooking into the correct level viewport callbacks).
	Added the ability for FEdModes to specify whether they can use a widget mode.
	Added a common set of commands that all Persona-based editors can opt into (only contains TogglePlay for now).

	#jira UE-35163 - Cannot use Play/Pause shortcut in Persona if viewport is focused

Change 3143100 on 2016/09/28 by James.Golding

	UE-32275  Fix Anim Curve entries losing Auto state when hidden/reshown

Change 3143107 on 2016/09/28 by Martin.Wilson

	Add check to IsRunningParallelEvaluation to verify that the skeletal mesh component in question still references us

	#jira UE-34431

Change 3143125 on 2016/09/28 by Jurre.deBaare

	PR #2749: Fix blend space triangulation (Contributed by tmiv)

Change 3143225 on 2016/09/28 by Jurre.deBaare

	Mesh/material merging basic test files

Change 3143235 on 2016/09/28 by Martin.Wilson

	Fix issue where montage wrong section was updated with changes from details panel when clicking on a new section

	#jira UE-35929

Change 3143312 on 2016/09/28 by Marc.Audy

	Don't globally reregister components, globally recreate render state instead when force deleting assets
	Fixes crash force deleting a blueprint with a child actor component in it from the content browser

Change 3143340 on 2016/09/28 by Mieszko.Zielinski

	Improved consistency of loudness usage in AISense_Hearing #UE4

Change 3143359 on 2016/09/28 by Marc.Audy

	Fix spelling error in comment

Change 3143372 on 2016/09/28 by Jurre.deBaare

	HLOD meshes are causing degenerate triangles
	#fix Setting flag to ignore degenerate triangles when building the meshes vertex/index buffers
	#jira UE-34336

Change 3143420 on 2016/09/28 by Mieszko.Zielinski

	Fix to BlackboardData initialization's dependency on parent asset's initialization #UE4

Change 3143421 on 2016/09/28 by Martin.Wilson

	Allow reading on animation sequence length in blueprints

	#jira UE-34168

Change 3143455 on 2016/09/28 by James.Golding

	Add 'noop' versions of DrawDebug function, so you will not get compile errors by default for calling them in Shipping/Test builds.
	Added optional SHIPPING_DRAW_DEBUG_ERROR define, which will give compile errors in Shipping/Test if still calling DrawDebug functions

Change 3143518 on 2016/09/28 by Jurre.deBaare

	Meshes with no UV Coordinates will break the UVs of other meshes contained in the same HLOD if they share a material
	#fix calculate UV bounds and check whether they occupy any space (if not do not use them for baking out the material)
	#misc set texture sampling for HLOD proxy base material to clamp
	#jira UE-35221

Change 3143542 on 2016/09/28 by James.Golding

	Change SHIPPING_DRAW_DEBUG_ERROR define from ifdef to if
	Fix comment
	Enable by default for FN

Change 3143543 on 2016/09/28 by Benn.Gallagher

	Changed branch + early return into an ensure during FPxQueryFilterCallback::preFilter. We were checking for invalid shapes in preFilter but that shouldn't happen. More likely to get some information as an ensure instead of earlying out on the funciton.

Change 3143556 on 2016/09/28 by Aaron.McLeran

	UE-36540 Editor Preferences 'Enable Sound' option causes Real Time Audio to Stop Working after PIE

Change 3143566 on 2016/09/28 by Benn.Gallagher

	Readded early out alongside new ensure for catching bad preFilter shapes

Change 3143568 on 2016/09/28 by Marc.Audy

	Fix deprecation warnings in UT

Change 3143572 on 2016/09/28 by Jurre.deBaare

	More test content for mesh/material merging

Change 3143581 on 2016/09/28 by Jurre.deBaare

	More content :D

Change 3143585 on 2016/09/28 by Jurre.deBaare

	Geometry cache cleaning
	#misc fix for missing materials, not serialized (facepalm) as they were added later on (required custom version bump)
	#misc cleaning out unecessary code

Change 3143594 on 2016/09/28 by Marc.Audy

	Creating a child actor component by dragging an actor blueprint in to another blueprint now properly creates the template
	#jira UE-36511

Change 3143658 on 2016/09/28 by Marc.Audy

	RootComponent can be null by the time we hit PostUnregisterAllComponents so need to protect against the dereference
	#jira UE-36553

Change 3143776 on 2016/09/28 by Marc.Audy

	Properly reinstance child actor templates when using the fast reinstancing path
	#jira UE-36516

Change 3143896 on 2016/09/28 by Ori.Cohen

	Remove UPROPERTY on aggregate threshold which is always read from the physics settings.

Change 3144022 on 2016/09/28 by Ben.Zeigler

	Move AIMoveTo node from BlueprintGraph to AIGraph and remove BlueprintGraph->AIModule dependency in build system

Change 3144252 on 2016/09/28 by mason.seay

	More blueprints for child actor template testing

Change 3144262 on 2016/09/28 by Mason.Seay

	Deleting assets

Change 3144283 on 2016/09/28 by dan.reynolds

	AEOverview update + Sound Priority Test

Change 3144411 on 2016/09/28 by dan.reynolds

	AEOverview end of day update and tweaks

Change 3144679 on 2016/09/29 by Benn.Gallagher

	Changed skeletal bounds calculation to not consider clothing assets that aren't simulating in the current LOD. In this case we're not rendering the clothing, we're only rendering the skeletal geometry for that section in that LOD which isn't bound to cloth.

Change 3144856 on 2016/09/29 by Jurre.deBaare

	HLOD Outliner scrolls back to the top when generating proxy meshes
	#fix OnLevelActorsAdded was getting called for actors in the thumbnail worlds, which forced a refresh on the listview
	#jira UE-30384

Change 3144864 on 2016/09/29 by Thomas.Sarkanen

	Preview mesh fixes

	Animation preview meshes are now respected (and saved). Mesh is displayed as empty if none is set (but a default is chosen).
	Skeleton preview meshes are now shown as empty if none is set (but a default is chosen).

	#jira UE-36582 - Cannot set preview mesh per-animation

Change 3144865 on 2016/09/29 by Jurre.deBaare

	More test content

Change 3144885 on 2016/09/29 by James.Golding

	UE-35307  Move 'invalid scale' warning to Message Log to be more visible in editor
	Change scale clamping in UpdateBodyScale to catch cases like (1,0,1)

Change 3144903 on 2016/09/29 by Thomas.Sarkanen

	Deprecating StaticMesh in UStaticMeshComponent

	Added GetStaticMesh to access the value as read-only.
	SetStaticMesh is now called in all locations that used to call "StaticMesh =".
	Lots of fixups.

	#jira UE-24859 - Deprecate public access to StaticMesh property in UStaticMeshComponent

Change 3145020 on 2016/09/29 by Thomas.Sarkanen

	Fix bounds calculations that include bones to respect LOD (and other requried bones)

	Sometimes bones would not be updated if we LOD switched, extending the bounds.

	#jira UE-36525 - UDebugSkelMeshComponent::CalcBounds should filter by LOD

Change 3145041 on 2016/09/29 by Jurre.deBaare

	Setting the Target Lightmap UV Channel to an incorrect value leads to inconsistent results
	#fix removed target light map channel, we now determine according to the UV channels which are unused in the final mesh
	#misc ignore the source lightmap uv channels to reduce data
	#jira UE-36595

Change 3145219 on 2016/09/29 by Benn.Gallagher

	Fixed clothing actors not casting shadows in editor, after the material editing change the copy of the shadow flag was missed from the clothing association code, which runs on again on older clothing assets to use the new render data skinning. Also added some fix up for assets that have be saved in the mean time.
	#jira UE-36552

Change 3145222 on 2016/09/29 by Jurre.deBaare

	Exporting Alembic Skeletal mesh from UE4 to FBX causes a crash
	#fix on import set _all_ bone influence to 0
	#jira UE-36602

Change 3145267 on 2016/09/29 by Ori.Cohen

	Move OnConstraintBreak delegate so that it fires outside of fetchResults. Fixes crash from user doing unsafe things during fetchResults.

	#JIRA UE-36483

Change 3145306 on 2016/09/29 by Jon.Nabozny

	Fixed PhAT so multiple constraints can be selected and edited properly at the same time.

	#JIRA: UE-31493

Change 3145342 on 2016/09/29 by Marc.Audy

	Do not update cull distance volumes whenever any property changes
	* Any movement or property change of a cull distance volume still does a global update
	* Any movement of a component belong to any other Actor updates only the components of that Actor
	* Any property change of a primitive component only updates that component
	#jira UE-36399

Change 3145958 on 2016/09/29 by Marc.Audy

	In game worlds don't auto activate components until the actor is ready to process them
	#jira UE-35189

Change 3146110 on 2016/09/29 by dan.reynolds

	AEOverview update + Soundwave Procedural Test Map

Change 3146375 on 2016/09/30 by Benn.Gallagher

	Fixed crash saving newly created destructible mesh after material refactor.
	#jira UE-36619

Change 3146378 on 2016/09/30 by James.Golding

	UE-35908 Line trace against a BodyInstance now returns closest hit for trimesh (was any hit before)
	Also add stat for FBodyInstance::LineTrace

Change 3146379 on 2016/09/30 by James.Golding

	Add test assets for creating procmesh collision in non-editor builds

Change 3146386 on 2016/09/30 by Thomas.Sarkanen

	Fixed ensures (and functionality) of 'show uncompressed animation' option in Persona viewports

	Made sure that PreEvaluateAnimation is called for th einstance in use, rather than only the preview instance.
	This unearthed another issuye where each of the calls to GenSpaceBAses was causing the animation to run faster. Fixed this by resetting the update flag in the update context after it is used.

	#jira UE-36251 - Ensures showing uncompressed animations in anim blueprints

Change 3146464 on 2016/09/30 by Thomas.Sarkanen

	Fix layered blend per bone odd/even connection counts alternately working/not working

	Older hacky fix for multi-property to array copies flip-flipped between using fast path and not, when it really should have disabled fast path after the first array pin. Now it disables fast path based on whether this is a new handler or not, rather than looking at the SimpleCopyPropertyName.

	#jira UE-35648 - Layered Blend Per Bone doesn't work correctly with 3+ inputs

Change 3146652 on 2016/09/30 by Benn.Gallagher

	Fixed subinstance properties appearing in the caller's details panel as oddly named properties.
	#jira UE-34141

Change 3146673 on 2016/09/30 by Martin.Wilson

	Make RawAnimationData (and associated anim sequence data) private

	#jira ue-25869

Change 3146680 on 2016/09/30 by Benn.Gallagher

	Fixed errant asterisks in tooltips for source and target bone on rotation multiplier controller node
	#jira UE-29847

Change 3146681 on 2016/09/30 by Benn.Gallagher

	Fixed incorrect tooltip on left hand IK bone in hand ik retargetting node
	#jira UE-30885

Change 3146711 on 2016/09/30 by Jon.Nabozny

	Fix PhAT SnapConstraintToBone.

	#jira UE-31491

Change 3146717 on 2016/09/30 by Danny.Bouimad

	Adding Jurres really useful merge actor test assets to somewhere QA can get em.

Change 3146738 on 2016/09/30 by Martin.Wilson

	Fix pose blending for on non-additive pose blending + remove normalising of weights for weights less than 1

	#tests Editor tests with mambo pose asset
	#jira UE-36189

Change 3146750 on 2016/09/30 by Jurre.deBaare

	Material baking issue
	#misc Removed the renderer initialization which causes issue the first time you would render out a material (gradient from top left to bottom right over the texture)
	#misc Replaced incorrect masks with _way_  better approach thanks to Martin

Change 3146755 on 2016/09/30 by Jurre.deBaare

	Need better progress bar for HLOD
	#fix replaced the progress updates with new more 'correct' ones according to the actual workload and fixed up the Simplygon progress callback
	#jira UE-34334

Change 3147085 on 2016/09/30 by Marc.Audy

	PR #2815: GetNextViewablePlayer now checking and returning correct PlayerState. (Contributed by joshkay)
	#jira UE-36632

Change 3147224 on 2016/09/30 by Martin.Wilson

	CIS Fix

Change 3147280 on 2016/09/30 by Marc.Audy

	Mouse smoothing should use application frame rate, not the dilated game frame rate
	#jira UE-31040

Change 3147446 on 2016/09/30 by Aaron.McLeran

	UE-36682 SoundCue Delay Not Consuming Input StartTime Correctly

Change 3147693 on 2016/09/30 by Ben.Zeigler

	#jira UE-36657
	If a player has an existing Pawn during RestartPlayer, use that pawn's rotation instead of the start spot, because we were already keeping the pawn's location

Change 3147697 on 2016/09/30 by Jon.Nabozny

	Add rotation parameter to FBodyInstance::Sweep and FBodyInstance::InternalSweepPhysX

	#jira UE-30486

Change 3147761 on 2016/09/30 by Jon.Nabozny

	Fix AUTRepulsorBubble UPrimitiveComponent::SweepComponent usage.

Change 3148533 on 2016/10/03 by Thomas.Sarkanen

	Fix new deprecation warnings introduced by the pull from main

Change 3148567 on 2016/10/03 by Marc.Audy

	Fix crash when exiting PIE while a panoramic screenshot is being taken
	Make stereo panorama tick with the world it is operating on
	#jira UE-36492

Change 3148571 on 2016/10/03 by Marc.Audy

	Allow modification of components that are EditAnywhere but don't exist in the CDO
	#jira UE-36694

Change 3148607 on 2016/10/03 by Martin.Wilson

	Properly end notify states when we clear the anim instance on a skeletal mesh.

	#jira UE-32488

Change 3148711 on 2016/10/03 by Martin.Wilson

	Fix type in virtual bone tooltip

	#jira UE-36703

Change 3148746 on 2016/10/03 by Benn.Gallagher

	Fixed a few cases where post process and sub instance anim calls weren't being made correctly.
	#jira UE-36529

Change 3148807 on 2016/10/03 by Martin.Wilson

	Fix mismatch skeleton error when undoing virtual bone changes

	#jira UE-36705

Change 3148812 on 2016/10/03 by Martin.Wilson

	Add undo support to removing virtual bones

	#jira UE-36706

Change 3148975 on 2016/10/03 by Jurre.deBaare

	Issue with combining meshes both with/without normal maps
	#fix make sure we always output atleast the default normal value when baking out materials, this to ensure we output non-black values for meshes without normal maps (this would cause the normal to be incorrect)
	#misc fixed issue in function to set texture rectangle to a single colour
	#misc spotted comparison error

Change 3148976 on 2016/10/03 by Ori.Cohen

	Make sure that shape queries that we pass into physx are never size 0. Fixes some NaNs

	#JIRA UE-36639

Change 3148991 on 2016/10/03 by Jurre.deBaare

	Changing LOD materials on Merged Actors Crashes Editor
	#fix take into account LOD that is using the material when remapping (removing duplicate) materials
	#jira UE-35883

Change 3148997 on 2016/10/03 by Jurre.deBaare

	Make sure we remove matrix samples that fall outside of the import range and remap those that are in range

Change 3149002 on 2016/10/03 by Jurre.deBaare

	Issues with importing Alembic caches using  matrix transformations
	#fix Apply conversion matrix to imported matrix samples to make them match the DCC package they were exported from

Change 3149030 on 2016/10/03 by Martin.Wilson

	Dont show save warning on animations when we have curve data

	#jira UE-34145

Change 3149115 on 2016/10/03 by Mieszko.Zielinski

	Made PathfollowingComponent distinct between patrial and full paths in terms of acceptance radius used, when trying to determin if pathing agent is at goal location #UE4

	#jira UE-35153

Change 3149186 on 2016/10/03 by Ben.Zeigler

	#UE-36722 Fix failure to spawn when trying to spawn 4 capsules in the exact same location
	There's no "Correct" direction to move out of a penetrating capsule, but old PhysX appeared to be consistent. New PhysX is not, so now we save and restore the adjustment instead of letting previous iterations modify it.
	This code is weird but this solution is better than the old version and handles inconsistent results

Change 3149235 on 2016/10/03 by Martin.Wilson

	Change inline curve name editing to only change the name of that specific curve, instead of renaming the smart name itself.

	#jira UE-20005

Change 3149245 on 2016/10/03 by Marc.Audy

	Remove duplicate entries from AttachChildren caused by lack of atomic cross-object updates.

Change 3149397 on 2016/10/03 by Ori.Cohen

	Fix collision profile writing out response values to channels that don't exist.

	#JIRA UE-36359

Change 3149679 on 2016/10/03 by Zak.Middleton

	#ue4 -  Don't mark CharacterMovementComponent::bUseControllerDesiredRotation as an advanced property. Consolidate rotation settings (RotationRate, bUseControllerDesiredRotation, bOrientRotationToMovement) in a new "Rotation Settings" category.

Change 3149929 on 2016/10/04 by Jurre.deBaare

	Fix for CIS errors
	#fix Mac didn't like undefined struct

Change 3149977 on 2016/10/04 by danny.bouimad

	Massive update to Merge Actor test files

Change 3150014 on 2016/10/04 by James.Golding

	UE-36686 Fix crash when slicing and not creating other section

Change 3150016 on 2016/10/04 by James.Golding

	UE-35335 MergeActors now converts box collision to convex, so collision scales correctly after merging

Change 3150019 on 2016/10/04 by James.Golding

	UE-36737 Fix LineTraceComponent not returning face index

Change 3150020 on 2016/10/04 by James.Golding

	UE-36672 Export PhysicsContstraintComponent class so it can be subclassed outside Engine module

Change 3150027 on 2016/10/04 by Ben.Marsh

	Add PhysX build option into Dev-Framework.

Change 3150042 on 2016/10/04 by Benn.Gallagher

	Fixed clothing example 1.3 collision glitches

Change 3150172 on 2016/10/04 by Benn.Gallagher

	Made Skeletal Mesh LOD reimports clear any existing simplification flag so we don't show "generated" next to LOD entries for them.
	#jira UE-36589

Change 3150319 on 2016/10/04 by Ori.Cohen

	Go back to only deferring body creation per component. This can now use the slow path when needed. Can't support deferring of multiple components without changing locking API so we'll do that in the future.

	#JIRA UE-36535, UE-36504

Change 3150355 on 2016/10/04 by Zak.Middleton

	#ue4 - Change checkSlow() to check() in GetDefaultObject<> because this is potentially an unsafe static cast.

Change 3150370 on 2016/10/04 by Ori.Cohen

	Fix deferred actors not getting flushed.

Change 3150386 on 2016/10/04 by Martin.Wilson

	Fix additive animation check failing in cooked builds when using virtual bones

	#jira UE-36743

Change 3150424 on 2016/10/04 by Ori.Cohen

	Exclude kinematic actors from active transforms generation.

Change 3150613 on 2016/10/04 by Zak.Middleton

	#ue4 - Fix bad GetDefaultObject<> in AbilitySystemGlobals. Turned up since changing checkSlow() to check() in GetDefaultObject.

	(Mirror CL 3138304  in Orion-DevGeneral)

	#jira UE-36810
	#tests compiled

Change 3150679 on 2016/10/04 by Ben.Zeigler

	Crash fix with no async scene

Change 3150765 on 2016/10/04 by Ben.Zeigler

	Deprecate UStructProperty::ExportTextItem_Static and ImportItem_Static, and add ExportText and ImportText directly to UScriptStruct
	Add bAllowNativeOverride to specify rather to call the native override. For unclear reasons the static export skipped the native override while the static import included it
	This allows calling the generic ImportText from inside a native ImportTextItem and then doing some post processing

Change 3150796 on 2016/10/04 by Marc.Audy

	Fix LOCTEXT warnings related to blueprint class menu options

Change 3150806 on 2016/10/04 by Ben.Zeigler

	Fix bad text format in import error message, lead to double error

Change 3150891 on 2016/10/04 by Ben.Zeigler

	#jira UE-36170 Fix duplicate GUID spam when async loading levels during PIE by checking the package flag instead of the runtime global

Change 3150914 on 2016/10/04 by Marc.Audy

	Don't try to recreate render state if it has already been recreated while the recreate context was active
	#jira UE-36590

Change 3151195 on 2016/10/04 by Dan.Reynolds

	Updates to QASoundWaveProcedural

	QASoundWaveProcedural edited to be a GameplayStatic which spawns an Audio Component Handler as well as a Procedural Sound Wave.  Support for envelope shaping (Attack, Sustain, Release) as well as multiple waveforms (Sine, Triangle, Sawtooth, Square).  Blueprint API expanded to include separate functions for setting QASoundWaveProcedural settings and Playing.

Change 3151233 on 2016/10/04 by Ben.Zeigler

	#jira UE-36836 Fix variable shadowing warnings

Change 3151328 on 2016/10/04 by dan.reynolds

	AEOverview Update - Added Sound Wave Procedural test map and added support for mobile (tested on Android) menu selection - Still a WIP

Change 3151461 on 2016/10/05 by Thomas.Sarkanen

	Fix localization warnings

	#jira UE-36720 - //UE4/Main: Step 'Build Engine Localization' - 2 Warnings

Change 3151546 on 2016/10/05 by Martin.Wilson

	Fix pose watch regression due to persona refactor changes.

	#jira UE-36851

Change 3151587 on 2016/10/05 by Jurre.deBaare

	Updating Simplygon to SDK version 8.0
	#misc removed redundant files
	#misc fixed landscape culling in merge actor path
	#misc added support for volume culling using simplygon
	#misc fixed when or not to use mesh data for material baking

	#notes
	Change: 3137650
	Date: 23/09/2016 07:57
	Client: Mustafa.Tungekar_Dev-Partner-Simplygon
	User: Mustafa.Tungekar
	Status: submitted
	Type: restricted
	ImportedBy:
	Identity:
	Description:
	-Renamed commandline variables for ZipUtils AutomationScript
	-Implemented Execute instead of ExecuteBuild
	-Updated commandline arguments in SimplygonSwarm
	JobStatus:
	Jobs:
	Files:
	//UE4/Dev-Partner-Simplygon/Engine/Source/Developer/SimplygonSwarm/Private/SimplygonSwarm.cpp#4
	//UE4/Dev-Partner-Simplygon/Engine/Source/Programs/AutomationTool/Scripts/ZipUtils.Automation.cs#2
	Change: 3137649
	Date: 23/09/2016 07:56
	Client: Mustafa.Tungekar_Dev-Partner-Simplygon
	User: Mustafa.Tungekar
	Status: submitted
	Type: restricted
	ImportedBy:
	Identity:
	Description:
	Moved file hash computation to ImportObject
	JobStatus:
	Jobs:
	Files:
	//UE4/Dev-Partner-Simplygon/Engine/Source/Editor/UnrealEd/Classes/Factories/Factory.h#4
	//UE4/Dev-Partner-Simplygon/Engine/Source/Editor/UnrealEd/Private/Factories/Factory.cpp#4
	Change: 3137646
	Date: 23/09/2016 07:55
	Client: Mustafa.Tungekar_Dev-Partner-Simplygon
	User: Mustafa.Tungekar
	Status: submitted
	Type: restricted
	ImportedBy:
	Identity:
	Description:
	Fixes CL3099204
	EditorPerProjectUserSetting
	Removed ConfigRestartRequired attribute from properties where it was not required
	MeshUtilities
	-Added FProxyFailedDelegate
	-Extended IMeshMerging to include FProxyFailed delegate
	-Added ProxyGenerationFailed method to FProxyGenerationProcessor class
	-Setup FailedDelegate for both MeshMerging and DistributedMeshMerging
	SimplygonMeshReduction
	-Added check for invalid texture id
	-Updated notes and removed commented code that is not required.
	-Setup failed delegate
	-Fixed issue where image data was never hooked into the texture.
	-Fixed issue where texture table was never passed into casters
	SimplygonSwarm
	-Setup failed delegate
	-Fixed RawMesh pointer usage.
	-Move helper method into SimplygonSwarmHelpers.h.
	-Added SimplygonSwarmHelpers
	-Removed redundant constant path to 7-zip
	-Removed GetSimplygonDirectory instead using inplace.
	-Removed commented code that is currently not required.
	-Fixed Typos
	JobStatus:
	Jobs:
	Files:
	//UE4/Dev-Partner-Simplygon/Engine/Source/Developer/MeshUtilities/Private/MeshUtilities.cpp#3
	//UE4/Dev-Partner-Simplygon/Engine/Source/Developer/MeshUtilities/Public/MeshUtilities.h#3
	//UE4/Dev-Partner-Simplygon/Engine/Source/Developer/SimplygonMeshReduction/Private/SimplygonMeshReduction.cpp#4
	//UE4/Dev-Partner-Simplygon/Engine/Source/Developer/SimplygonSwarm/Private/SimplygonSwarm.cpp#3
	//UE4/Dev-Partner-Simplygon/Engine/Source/Developer/SimplygonSwarm/Public/SimplygonSwarmHelpers.h#1
	//UE4/Dev-Partner-Simplygon/Engine/Source/Editor/UnrealEd/Classes/Editor/EditorPerProjectUserSettings.h#3
	Change: 3099204
	Date: 24/08/2016 07:56
	Client: Mustafa.Tungekar_Dev-Partner-Simplygon
	User: Mustafa.Tungekar
	Status: submitted
	Type: restricted
	ImportedBy:
	Identity:
	Description:
	Simplygon 8.0 Updates
	Deprecated support for 7.0 and updated SimplygonSwarm and SimplygonMeshReduction to use 8.0
	EditorPerProjectSettings
	*SwarmMaxUploadChunkSizeInMB for limiting the max upload size for swarm. Note the Simplygon Grid has a limitation of 2GB
	*SwarmNumOfConcurrentJobs for executing number of concurrent jobs
	*Fixed issue where SG_MATERIAL_CHANNEL_METALLIC to SG_MATERIAL_CHANNEL_METALNESS (Chage in 8.0 SDK)
	SPL, SimplygonSwarm, RESTClient
	*Bumped up SPL Version to 8
	*Fixed code paths to use ZipUtils UAT script for zipping and unzipping CL3094374
	*Removed SPL Templates for version 7.0
	*Added conditional logging to REST methods
	*Added multi part upload. The RESTClient automatically decided if large files need to be split up before uploading to simplygon grid.
	*Updated method to take in texturepath
	SimplygonMeshReduction
	*Removed minimum version requirement.
	*Bumped up minimum version
	*Chagned license file name to refelect 8.0 changes
	*MaterialBaking related method now take in TextureTable as an extra parameter. This is due to 8.0 move away from old way of setting up materials and using SimplygonShadingNetowrk based appraoch.
	JobStatus:
	Jobs:
	Files:
	//UE4/Dev-Partner-Simplygon/Engine/Source/Developer/SimplygonMeshReduction/Private/SimplygonMeshReduction.cpp#3
	//UE4/Dev-Partner-Simplygon/Engine/Source/Developer/SimplygonMeshReduction/Public/SimplygonTypes.h#2
	//UE4/Dev-Partner-Simplygon/Engine/Source/Developer/SimplygonSwarm/Private/SimplygonRESTClient.cpp#3
	//UE4/Dev-Partner-Simplygon/Engine/Source/Developer/SimplygonSwarm/Private/SimplygonSwarm.cpp#2
	//UE4/Dev-Partner-Simplygon/Engine/Source/Developer/SimplygonSwarm/Public/SimplygonRESTClient.h#2
	//UE4/Dev-Partner-Simplygon/Engine/Source/Developer/SimplygonSwarm/Public/SimplygonSwarmPrivatePCH.h#2
	//UE4/Dev-Partner-Simplygon/Engine/Source/Editor/UnrealEd/Classes/Editor/EditorPerProjectUserSettings.h#2
	//UE4/Dev-Partner-Simplygon/Engine/Source/Editor/UnrealEd/Private/Settings/EditorPerProjectUserSettings.cpp#2
	Change: 3099200
	Date: 24/08/2016 07:48
	Client: Mustafa.Tungekar_Dev-Partner-Simplygon
	User: Mustafa.Tungekar
	Status: submitted
	Type: restricted
	ImportedBy:
	Identity:
	Description:
	#fix Copy constructor for FMeshReduciton mapped ShadingImportance to SilhouetteImportance
	JobStatus:
	Jobs:
	Files:
	//UE4/Dev-Partner-Simplygon/Engine/Source/Runtime/Engine/Classes/Engine/MeshMerging.h#2
	Change: 3099199
	Date: 24/08/2016 07:47
	Client: Mustafa.Tungekar_Dev-Partner-Simplygon
	User: Mustafa.Tungekar
	Status: submitted
	Type: restricted
	ImportedBy:
	Identity:
	Description:
	Added Automation Script ZipUtils to zip file and unzip files from SimplygonSwarm.
	This will remove any dependency on external zip program and should work across platforms
	JobStatus:
	Jobs:
	Files:
	//UE4/Dev-Partner-Simplygon/Engine/Source/Programs/AutomationTool/Scripts/AutomationScripts.Automation.csproj#2
	//UE4/Dev-Partner-Simplygon/Engine/Source/Programs/AutomationTool/Scripts/ZipUtils.Automation.cs#1
	Change: 3099197
	Date: 24/08/2016 07:40
	Client: Mustafa.Tungekar_Dev-Partner-Simplygon
	User: Mustafa.Tungekar
	Status: submitted
	Type: restricted
	ImportedBy:
	Identity:
	Description:
	*Speed improvements for FBX Scene Importer
	*Added a static method to compute Hash.
	JobStatus:
	Jobs:
	Files:
	//UE4/Dev-Partner-Simplygon/Engine/Source/Editor/UnrealEd/Classes/Factories/Factory.h#3
	//UE4/Dev-Partner-Simplygon/Engine/Source/Editor/UnrealEd/Private/Factories/Factory.cpp#3
	//UE4/Dev-Partner-Simplygon/Engine/Source/Editor/UnrealEd/Private/Fbx/FbxStaticMeshImport.cpp#2
	//UE4/Dev-Partner-Simplygon/Engine/Source/Runtime/Engine/Classes/EditorFramework/AssetImportData.h#2
	//UE4/Dev-Partner-Simplygon/Engine/Source/Runtime/Engine/Private/EditorFramework/AssetImportData.cpp#2

Change 3151664 on 2016/10/05 by Richard.Hinckley

	Fixing ACharacter template for "New C++ Class" feature. Avoiding naming a function parameter the same as an existing class member.

Change 3151729 on 2016/10/05 by Thomas.Sarkanen

	Audit of remaining NaN checks

	Some checks remain on in shipping (generally those called from blueprint):

	- AActor::TeleportTo
	- AActor::SetActorRelativeScale3D

	#jira UE-30999 - Optimize ⌠ContainsNaN÷ and ⌠ContainsNaNOrInfinite÷, audit those still in shipping/test

Change 3151742 on 2016/10/05 by Ori.Cohen

	Make sure that if physical animation component doesn't find a body and bone it doesn't crash.

	#JIRA UE-36839

Change 3151756 on 2016/10/05 by Jurre.deBaare

	Fixing d3dcompiler_47.dll missing issue
	#fix added runtime dependency and dll name to build.cs file
	#fix now load the d3dcompiler_47.dll from the Binaries/ThirdParty/Windows folder before loading the simplygon DLL

Change 3151761 on 2016/10/05 by Thomas.Sarkanen

	Fix deprecation warning from last integration

	Moved Preview to EditorPreview in FEditorWorldManager::OnWorldContextAdd.

	#jira UE-36858 - Compile UE4Editor* completed with 1 warning

Change 3151782 on 2016/10/05 by Jurre.deBaare

	Simplygon patch up
	#misc linker errors popping up from JSONCPP
	#misc incorporated emissive material property fix from other shelve
	#misc static analysis fix

Change 3151804 on 2016/10/05 by Marc.Audy

	Clear need end of frame update when unregistering a component

Change 3151928 on 2016/10/05 by Ori.Cohen

	Fix runtime DLLs not including all delay loaded physx dll files.

	#JIRA UE-36816

Change 3151977 on 2016/10/05 by Martin.Wilson

	Notifies can no longer occupy the same time on the same track.

	#jira UE-30658

Change 3151989 on 2016/10/05 by Jon.Nabozny

	Fix ArchVis character rotation pitch when looking up/down.

	#jira UE-35706

Change 3152083 on 2016/10/05 by Marc.Audy

	Ensure that pending kill components get their marked for end of frame state cleared.

Change 3152086 on 2016/10/05 by Ben.Zeigler

	#jira UE-36169 Fix it so missing linker errors that point to Blueprint CDOs are skipped, the same way it skips linker errors going to the actual class. Fixes a lot of spurious warnings from deleting components from blueprints or native classes
	Clean up the VerifyImport error handling so it also displays in -game and cook, and fix the missing class warning to work properly, previously it would happen 0% in development 100% in debug even if the class was valid

Change 3152093 on 2016/10/05 by Marc.Audy

	Change logic for when location cannot be changed for a static component to be independent of has begun play and have to do with whether construction script is running or the level is in the process of loading (mostly for backwards compatibility adjustments in post load).
	#jira UE-36146
	#jira UE-24647

Change 3152100 on 2016/10/05 by Ben.Zeigler

	Remove pragma optmize

Change 3152112 on 2016/10/05 by Marc.Audy

	Merging //UE4/Dev-Main to Dev-Framework (//UE4/Dev-Framework) @ 3152072

Change 3152134 on 2016/10/05 by Jurre.deBaare

	Simplygon/Merge actor issues
	#fix for emissive output on meshes that do not have emissive properties
	#fix for texture binning, not removing invalid split area causing overlapped textures

Change 3152136 on 2016/10/05 by James.Golding

	UE-36859 Fix tooltip saying you can click to stop recording

Change 3152169 on 2016/10/05 by James.Golding

	UE-31209 UE-30935 : Expose bDeformableMesh and bFastCook options in FTriMeshCollisionData
	ProceduralMeshComponent will now cook using 'fast' and 'deformable' options, so updating collision on sections should work correctly
	Change ERuntimePhysxCookOptimizationFlags to EPhysXMeshCookFlags and use that to pass options to CookConvex and CookTriMesh

Change 3152202 on 2016/10/05 by Jurre.deBaare

	Mac/Linux fix

Change 3152303 on 2016/10/05 by Marc.Audy

	Fix deprecation warning post merge from main

Change 3152320 on 2016/10/05 by Martin.Wilson

	Fix root motion from everything calculating incorrect root motion when animations haven't been ticking

	#jira UE-35364

Change 3152354 on 2016/10/05 by James.Golding

	PoseDriver should pass through if no poses activated

Change 3152357 on 2016/10/05 by James.Golding

	UE-36844 Remove unused OnAssetModifiedNotifier delegate from PoseAsset, ensure OnPoseListChanged is called when updating PoseAsset from anim.

Change 3152556 on 2016/10/05 by Marc.Audy

	Remove autos

Change 3152560 on 2016/10/05 by Marc.Audy

	Don't allow child actor references to be dragged from the outliner to a level script
	#jira UE-16700

Change 3152568 on 2016/10/05 by Marc.Audy

	Don't allow non-networking code to set bRemoteOwned in the actor spawn parameters
	Remove deprecated bNoCollisionFail
	#jira UE-35928

Change 3152575 on 2016/10/05 by Marc.Audy

	Allow construction script to run post move for native classes. Actor can determine whether it should only occur on finish or every call to post edit move

Change 3153101 on 2016/10/06 by Thomas.Sarkanen

	Fix crash re-opening the viewport in Persona-based editors

	#jira UE-36775 - Editor crashes when re-opening viewport in Persona

Change 3153139 on 2016/10/06 by James.Golding

	UE-36908 Remove GetRuntimeOnlyCookOptimizationFlags if cooking is not supported

Change 3153160 on 2016/10/06 by Thomas.Sarkanen

	Fix for crash when deleting additive layer track

	Code had not been updated to use the new delgate system (was still using reciprocal FPersona ptr).

	#jira UE-36740 - Crash when removing or disabling an additive layer track in Persona

Change 3153175 on 2016/10/06 by Benn.Gallagher

	Fixed crashes when using subinstances in non-default states. we previously initialized the anim instances in the node initialize, but in states that haven't been hit by an initialize this will happen off the game thread which is not allowed.
	#jira UE-36900

Change 3153223 on 2016/10/06 by Thomas.Sarkanen

	Fixed crash when opening an asset from the blend space editor

	Code was still trying to open 'old' Persona when it was disabled.
	Also fix other call sites where this was being done outside of asset type actions.

	#jira UE-36766 - Crash attempting to open an asset from Aim Offset graph in Persona

Change 3153324 on 2016/10/06 by Thomas.Sarkanen

	Prevented invalid GUIDs from being saved into smart name containers

	AddOrFindName now checks to see if existing GUIDs are valid before using them.
	AddName now requires a valid GUID to be passed in.
	Also added Modify() call to the skeleton when FindOrAddSmartName is called from VerifySmartNameInternal, as without  this the skeleton might not get saved.
	Also add Laurent's fix for fixing up already-saved invalid GUIDs (CL 3138068).

	#jira UE-36367 - It is possible for curves with an invalid GUID to be saved into the USkeleton asset

Change 3153348 on 2016/10/06 by Martin.Wilson

	Re add ticking code so all Persona editors viewports tick during drag events (went missing in Persona refactor)

	#jira UE-36751

Change 3153426 on 2016/10/06 by Mieszko.Zielinski

	Added missing elements of block comments support in BT editor #UE4

Change 3153454 on 2016/10/06 by Benn.Gallagher

	Fixed crash using anim debug with subinstances that are preceded by branching nodes.
	#jira UE-36935

[CL 3153517 by Ori Cohen in Main branch]
2016-10-06 12:11:11 -04:00

3512 lines
109 KiB
C++
Raw Blame History

// Copyright 1998-2016 Epic Games, Inc. All Rights Reserved.
#include "LaunchPrivatePCH.h"
#include "Internationalization/Internationalization.h"
#include "Ticker.h"
#include "ConsoleManager.h"
#include "ExceptionHandling.h"
#include "FileManagerGeneric.h"
#include "TaskGraphInterfaces.h"
#include "StatsMallocProfilerProxy.h"
#include "Projects.h"
#include "UProjectInfo.h"
#include "EngineVersion.h"
#include "ModuleManager.h"
#include "../Resources/Version.h"
#include "VersionManifest.h"
#include "UObject/DevObjectVersion.h"
#include "HAL/ThreadHeartBeat.h"
#include "MallocProfiler.h"
#include "NetworkVersion.h"
#if WITH_COREUOBJECT
#include "Internationalization/PackageLocalizationManager.h"
#include "CoreUObject.h"
#endif
#if WITH_EDITOR
#include "EditorStyle.h"
#include "ProfilerClient.h"
#include "RemoteConfigIni.h"
#include "EditorCommandLineUtils.h"
#if PLATFORM_WINDOWS
#include "AllowWindowsPlatformTypes.h"
#include <objbase.h>
#include "HideWindowsPlatformTypes.h"
#endif
#endif
#if WITH_ENGINE
#include "AudioThread.h"
#include "AutomationController.h"
#include "Database.h"
#include "DerivedDataCacheInterface.h"
#include "RenderCore.h"
#include "ShaderCompiler.h"
#include "DistanceFieldAtlas.h"
#include "GlobalShader.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 "HotReloadInterface.h"
#include "ISessionService.h"
#include "ISessionServicesModule.h"
#include "Engine/GameInstance.h"
#include "Net/OnlineEngineInterface.h"
#include "Internationalization/EnginePackageLocalizationCache.h"
#if !UE_SERVER
#include "HeadMountedDisplay.h"
#include "ISlateRHIRendererModule.h"
#include "ISlateNullRendererModule.h"
#include "EngineFontServices.h"
#endif
#include "MoviePlayer.h"
#if !UE_BUILD_SHIPPING
#include "STaskGraph.h"
#include "ProfilerService.h"
#endif
#if WITH_AUTOMATION_WORKER
#include "AutomationWorker.h"
#endif
#endif //WITH_ENGINE
#if WITH_EDITOR
#include "FeedbackContextEditor.h"
static FFeedbackContextEditor UnrealEdWarn;
#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
// 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 TScopedPointer<FOutputDeviceConsole> GScopedLogConsole;
static TScopedPointer<FOutputDeviceStdOutput> GScopedStdOut;
static TScopedPointer<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.IsValid());
GScopedStdOut = new FOutputDeviceStdOutput();
GLog->AddOutputDevice(GScopedStdOut.GetOwnedPointer());
}
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 = 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 = new FOutputDeviceTestExit(ExitPhrasesList);
GLog->AddOutputDevice(GScopedTestExit.GetOwnedPointer());
}
}
}
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 USE_NEW_ASYNC_IO
{
GIOThreadPool = FQueuedThreadPool::Allocate();
int32 NumThreadsInThreadPool = FPlatformMisc::NumberOfIOWorkerThreadsToSpawn();
if (FPlatformProperties::IsServerOnly())
{
NumThreadsInThreadPool = 2;
}
verify(GIOThreadPool->Create(NumThreadsInThreadPool, 16 * 1024, TPri_AboveNormal));
}
#endif // USE_NEW_ASYNC_IO
#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.GetOwnedPointer();
LoadPreInitModules();
// Start the application
if(!AppInit())
{
return 1;
}
#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.IsValid() && !bHasEditorToken && !bIsRegularClient && !IsRunningDedicatedServer())
{
InitializeStdOutDevice();
}
#if !USE_NEW_ASYNC_IO
FIOSystem::Get(); // force it to be created if it isn't already
#endif
// 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();
}
// 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;
}
#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 );
GetMoviePlayer()->SetSlateRenderer(SlateRenderer);
}
// Create the engine font services now that the Slate renderer is ready
FEngineFontServices::Create();
#endif
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
if ( !IsRunningDedicatedServer() )
{
// @todo ps4: If a loading movie starts earlier, which it probably should, then please see PS4's PlatformPostInit() implementation!
// 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();
GetMoviePlayer()->Initialize();
GetMoviePlayer()->PlayMovie();
// 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);
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();
}
#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 );
}
GIsRequestingExit = true; // so CTRL-C will exit immediately
// 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();
// 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_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"));
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 AbilitySystem editor as early as possible for statically initialized assets (non cooked BT assets needs it)
// cooking needs this module too
bool bGameplayAbilitiesEnabled = false;
GConfig->GetBool(TEXT("GameplayAbilities"), TEXT("GameplayAbilitiesEditorEnabled"), bGameplayAbilitiesEnabled, GEngineIni);
if (bGameplayAbilitiesEnabled)
{
FModuleManager::Get().LoadModule(TEXT("GameplayAbilitiesEditor"));
}
// -----------------------------------------------------
// 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"));
}
// Needed for extra Blueprint nodes that can be used in standalone.
FModuleManager::Get().LoadModule(TEXT("GameplayTagsEditor"));
#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 !USE_NEW_ASYNC_IO
FIOSystem::Shutdown();
#endif
}
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;
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 "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));
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 (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 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();
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
#if WITH_ENGINE
if (!IsRunningCommandlet())
{
// 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
// --
// Why load HTTP?
// Because most, if not all online subsystems will load HTTP themselves. This can cause problems though, as HTTP will be loaded *after* OSS,
// and if OSS holds on to resources allocated by it, this will cause crash (modules are being unloaded in LIFO order with no dependency tracking).
// Loading HTTP before OSS works around this problem by making ModuleManager unload HTTP after OSS, at the cost of extra module for the few OSS (like Null) that don't use it.
// These should not be LoadModuleChecked because these modules might not exist
FModuleManager::Get().LoadModule(TEXT("XMPP"));
FModuleManager::Get().LoadModule(TEXT("HTTP"));
// OSS Default/Console are loaded in plugins immediately following
}
#endif
// 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 USE_NEW_ASYNC_IO
if (GIOThreadPool != nullptr)
{
GIOThreadPool->Destroy();
}
#endif // USE_NEW_ASYNC_IO
#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