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
6e1c88d0b983bae8e7ea495db6fa97c8a30dbbdf
UnrealEngineUWP/Engine/Source/Programs/AutomationTool/AutomationUtils/ProjectParams.cs
Bob Tellez 45f1743d16 Copying //UE4/Fortnite-Staging to //UE4/Dev-Main (Source: //Fortnite/Main @ 3115282) 
#lockdown Nick.Penwarden

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

Change 3114846 on 2016/09/06 by Bob.Tellez

	#UE4 The cooking process now respects the per-platform chunking manifest configuration in the game ini. If you specify -manifests it forces all platforms to generate a manifest.

Change 3114805 on 2016/09/06 by Bob.Tellez

	#UE4 Attribute sets now work with their owning actor directly instead of asking the associated ability system component for the owning actor when updating the vis logger.

	#JIRA FORT-29511

Change 3112750 on 2016/09/02 by Bob.Tellez

	#UE4 bGenerateChunks from platform-specific Game.ini is now respected in pak generation code.

Change 3108977 on 2016/08/31 by Jeff.Campeau

	Virtual keyboard support for Xbox One
	Text set by virtual keyboards is now submitted on the main thread through an internal tick

Change 3108956 on 2016/08/31 by Chris.Gagnon

	Added "ClientOnly" module type to the build tools.
	Fixed "ServerOnly" which seems to have rotted, I assume it wasn't in use as it didn't work.
	Cleaned up some duplicated code which attributted to the rot most likely

Change 3108879 on 2016/08/31 by Jeff.Campeau

	Eliminate binary renaming (allows side by side configs)
	Handle multiple binaries
	Temporary return of fixed extension SDK DLLs (required for multiplayer until they can be dynamically configured)

Change 3108876 on 2016/08/31 by Jeff.Campeau

	Fix a manifest generation bug that was eating a character on conjoined values.

Change 3108511 on 2016/08/31 by Billy.Bramer

	- Submit change from JoshM at my desk to make cloud mcp requests use shared pointers for net ids, enabling the use of AsShared on cloud-related callbacks which pass net ids as parameters
	- Note that this change does not have any validity checking as of yet

Change 3108199 on 2016/08/31 by Ben.Woodhouse

	Disable r.lightshaftrendertoseparatetranslucency to 0 by default, but enable in fortnite via defaultEngine.ini.

Change 3107825 on 2016/08/31 by Ben.Woodhouse

	Lightshaft rendering - add support for rendering the lightshafts to separate translucency (via the r.LightShaftRenderToSeparateTranslucency). This ensures postprocess materials with BL_BeforeTranslucency are rendered before lightshafts are applied. This fixes issues with the skin postprocess appearing too bright where it overlaps with lightshafts

	#jira UE-35359

Change 3107197 on 2016/08/30 by Chris.Gagnon

	Added ClientOnly option for Modules:

	...
	"Modules" :
	  [
	    {
	      "Name" : "PluginName",
	      "Type" : "ClientOnly",
	      "LoadingPhase" : "Default"
	    }
	  ]
	...
	(example taken from a plugin definition)

Change 3104551 on 2016/08/29 by Lukasz.Furman

	potential fix for crash in ability cancelling
	#jira FORT-29200

Change 3104469 on 2016/08/29 by Lukasz.Furman

	added iteration limit to navmesh raycast loop to protect against invalid navmesh links creating an infinite loops
	#jira FORT-29198

Change 3103529 on 2016/08/26 by Jeff.Campeau

	Xbox One keyboard shift is sometimes unresponsive

Change 3103523 on 2016/08/26 by Jeff.Campeau

	Aug XDK era launch bug fixed

Change 3103183 on 2016/08/26 by Jeff.Campeau

	August XDK support

Change 3102360 on 2016/08/26 by James.Hopkin

	Removed another load of float casts - these ones weren't causing problems, but are no longer necessary.

Change 3099375 on 2016/08/24 by Lukasz.Furman

	added sanity check to UAnimInstance::Montage_Play
	#jira FORT-28140

Change 3097832 on 2016/08/23 by Chad.Garyet

	moving set_latest_build out of notifications section, was put there accidentally

Change 3097139 on 2016/08/22 by Aaron.McLeran

	FORT-28502 Hard crash occurs on Win10 when locking computer and then unplugging audio device

	- Fix is modification of CL 3062338. Moving the checking of state change to head of audio update, adding new thread safe bool to immediately halt creatiing new voices if audio device changed.
	- Current theory is the xaudio2 in win10 doesn't properly handle audio device remove so this is a workaround till we update to XAudio2 2.8

	-#rb Bob.Tellez
	#tests run game, lock computer, then disable or unplug audio device used by game, audio should stop gracefully without crashing

Change 3096552 on 2016/08/22 by Ben.Marsh

	Fix killing adb.exe instead of notepad.exe.

Change 3096473 on 2016/08/22 by Ben.Marsh

	Kill any ADB processes after a UAT command completes. The Android target platform in the editor spawns instances of ADB, and that spawns a background process to handle this and future requests. It can keep open handles to stdout, preventing the EC postprocessor from terminating.

Change 3096459 on 2016/08/22 by Ben.Marsh

	Remove taskkill call for now.

Change 3096450 on 2016/08/22 by Ben.Marsh

	Use system function instead of backticks to prevent errors killing job.

Change 3096449 on 2016/08/22 by Ben.Marsh

	Kill ADB instances after running UAT; attempt to fix handle to stdout being kept open at the end of builds.

Change 3096272 on 2016/08/22 by Chad.Garyet

	trying to remove postpfilter to see if that might be the stdout/err issue

Change 3095369 on 2016/08/19 by Ben.Zeigler

	#Jira FORT-28683 Fix it so when using SimulateInEditor with Online PIE enabled, it disables trying to use the online service.  Before it would half create the online instances, leading to issues in gameplay code when using simulate
	This will need updating when merging to Main to deal with the module changes

Change 3095002 on 2016/08/19 by James.Hopkin

	Fixed another case of integers being cast to floats before being written to JSON.

	#jira FORT-28694

Change 3094834 on 2016/08/19 by Chad.Garyet

	trying a close of stdout and stderr to see if that remedies the ai test issue

Change 3094719 on 2016/08/19 by John.Abercrombie

	Force a net update on the Avatar Actor whenever we start or stop a new Montage

Change 3094487 on 2016/08/19 by James.Hopkin

	JSON writing of session settings no longer casts ints to floats (was causing INT_MIN to be written incorrectly).

Change 3092389 on 2016/08/17 by Chad.Garyet

	more caveman debugging, skipping email notification if node is the fortnite ai test node.

Change 3090898 on 2016/08/16 by Aaron.McLeran

	FORT-25911 Live OT7 crash in FVorbisAudioInfo::ReadCompressedData

	Implementing CL 3080958 in FN

Change 3090761 on 2016/08/16 by Chris.Gagnon

	Added initial pass of safe zone suport to the front end.

Change 3090734 on 2016/08/16 by John.Abercrombie

	Fix AbilitySystemComponent not ticking while playing a montage, and ticking when we're not playing a montage

	Here's the issue in the version of the code prior to this checkin:
	- UpdateShouldTick calls GetShouldTick, which checks the value of RepAnimMontageInfo.IsStopped
	- When we call UpdateShouldTick within AnimMontage_UpdateReplicatedData, we haven't set RepAnimMontageInfo.IsStopped yet to the correct value
	- So when we aren't playing any montages but are starting a new one, we were saying we shouldn't tick
	- It also means if we were playing a montage, and then stop, we'll start ticking
	- Ticking calls AnimMontage_UpdateReplicatedData, which should be called while we're playing

Change 3090405 on 2016/08/16 by Chad.Garyet

	checking in caveman debugging for fortnite ai test node

Change 3089743 on 2016/08/15 by Ben.Zeigler

	#jira FORT-28235
	When a UWidget is added/removed from a UPanelWidget, invalidate layout. This fixes issues where removing a widget leaves it still visible on screen.
	There may be a better slate-level solution to this issue

Change 3088178 on 2016/08/12 by Saul.Abreu

	Fixed bug in wrap box layout logic that would cause the inner slot vertical padding to only be added *after* the second row.

Change 3087372 on 2016/08/12 by James.Hopkin

	Added a float overload from TJsonWriter::WriteValue - ever since I made doubles ultra precise to allow large numbers to be read properly, floats have been written with garbage on the end. Also removed 100 lines worth of code duplication while I was there. Automation tests still pass.

Change 3084836 on 2016/08/10 by Lina.Halper

	Fix crash with retargeting additive anim montage

Change 3083188 on 2016/08/09 by Bob.Tellez

	#UE4 UEnvQueryItemType_Point expects a FNavLocation instead of an FVector. Since passing an FVector in AddItemData() causes an assertion failure and the template specialization for FNavLocation has linkage problems, it is now required to pass in a FNavLocation instead of an FVector explicitly.

Change 3082835 on 2016/08/09 by Bob.Tellez

	#UE4 Fix an issue where changing an array property in the defaults will leave the custom property chain stale until it is compiled, causing a crash in some circumstances.

Change 3082621 on 2016/08/09 by Lukasz.Furman

	fixed accessing empty navigation data in crowd's path processing
	#jira FORT-27847

Change 3081749 on 2016/08/08 by Saul.Abreu

	#jira UE-34104
	Implemented a customizable snapshot delay in the widget reflector - particularly handy for getting snapshots of tooltips.

Change 3081596 on 2016/08/08 by John.Abercrombie

	Added a tick prerequisite for the mesh's primary actor tick of the FortGameState when a movement comp registers to be ticked by the game state

	Backed out change to CharacterMovementComponent to check to see if the pose had been ticked this frame.

	Tested root motion in PIE ded, PIE non-ded, and client/server configuration and it all looked good.

	(Basically it looks like there's some tick ordering issue with root motion in the engine, and I don't have the time right now to investigate it.  This works.)

	#jira FORT-28139 - Hero's animation hitches when performing any action besides walking and jumping

Change 3081536 on 2016/08/08 by Daniel.Broder

	Fixed bug in FGameplayTagContainer::AppendTags() where it was not reserving the correct amount of space for all of the tags it is about to add.

	#UE4 #NoReleaseNotes

Change 3080679 on 2016/08/08 by Simon.Tovey

	Increased threshold to ignore stall warning on partilce async work.
	Increased precision of error message.
	May still fire and still needs looking into properly.
	If it does fire still I'll make it a higher priority.

Change 3080652 on 2016/08/08 by Chad.Garyet

	Merging token scripts from ue4 main to fortnite
	changed fornite main json scheduled builds to all use skiptargetswithouttickets

Change 3079357 on 2016/08/05 by John.Abercrombie

	Character movement components can now be throttled
	- This can be enabled/disabled by using the FortniteChar.ServerTickMovementAtNetUpdateRate console variable - game should be restarted after toggling it
	- Character movement components are throttled based on their current NetUpdateRate

	All character movement components are updated by the Game State
	- This can be enabled/disabled by using the FortniteChar.CentralCharMovementTick console variable - game should be restarted after toggling it

Change 3078666 on 2016/08/05 by Simon.Tovey

	Disabling some log spam for particles.

Change 3072992 on 2016/08/01 by Jonathan.Lindquist

	Fixing a bug related to weld object seams

Change 3070991 on 2016/07/29 by Fred.Kimberley

	Allow aggregators to perform calculations while ignoring multiple GEs.

Change 3070518 on 2016/07/29 by Bob.Tellez

	#UE4 Deprecated pin removal logic is now exclusively in UEdGraphNode::PostLoad. DeprecatedPinWatches fixup is now done in K2Node::PostLoad.

Change 3069605 on 2016/07/28 by Bob.Tellez

	#UE4 SScrollBox now works with invalidation panels.

Change 3069600 on 2016/07/28 by Bob.Tellez

	#UE4 SMenuAnchor now works with invalidation panels.

Change 3069583 on 2016/07/28 by Bob.Tellez

	#UE4 Added some code to warn and recover from some invalid accounting of render instances in HierarchicalInstancedStaticMesh, if it exists in the future.

Change 3068935 on 2016/07/28 by Bob.Tellez

	[AUTOMERGE]

	#UE4 Added a CVar to disable stencils on metal since they are very expensive right now. This is believed to be much better in OSX 10.12.

	#JIRA FORT-27836

	--------
	Integrated using branch //Fortnite/Main-To-//Fortnite/Release-Next (reversed) of change#3068932 by Bob.Tellez on 2016/07/28 15:50:40.

Change 3068422 on 2016/07/28 by John.Pollard

	Fix FORT-27840 - Assertion failed: WriterState.Changed.Num() == 0 occurs when a Pitcher Husk hits the Player

	#tests Live game + replays

Change 3067537 on 2016/07/27 by Bob.Tellez

	[AUTOMERGE]

	#UE4 Nullifying HierarchicalInstancedStaticMesh instances that were neither in the PerInstanceSMData list nor in the RemovedInstances list.

	#JIRA FORT-26696

	--------
	Integrated using branch //Fortnite/Main-To-//Fortnite/Release-Next (reversed) of change#3065681 by Bob.Tellez on 2016/07/26 21:02:55.

Change 3065138 on 2016/07/26 by Josh.Markiewicz

	#UE4 - fixed rare case where CreateSession would crash  (duplicate of Dev-Networking fix)
	- DestroySession now always adds a task to the async queue and never tries to complete its work within the same call
	- *BUG REPRO*
	- if CreateSession was called leaving a session in the Creating state followed by a call to DestroySession before session left Creating state this could happen
	- DestroySession would remove the named session while the previous CreateSession was in flight
	- A new CreateSession could be called afterward because the previous named session was removed
	- the first CreateSession would finish and give the session a valid SessionInfo
	- the second CreateSession would finish and assert that the SessionInfo should be invalid
	#tests contrived Create,Destroy,Create in same frame and saw crash, fixed code, crashes no more

Change 3064932 on 2016/07/26 by Tim.Tillotson

	Fix for editor crash when loading unreal stats in the session frontend. Was a results of modifying EventMetadata while using a copy of the data.

	#JIRA UE-33426

Change 3064743 on 2016/07/26 by Mark.Satterthwaite

	Proper fix for FORT-27685 - on Metal it is invalid to fail to set uniform parameters on a shader - if you don't set the parameter the buffer binding may be nil or too small for the data accessed in the shader and the GPU will then crash.
	#jira FORT-27685

Change 3063870 on 2016/07/25 by Lukasz.Furman

	fixed navlink area class assignment, again
	custom link definitions were exporting from CDO without initializing data first
	#jira FORT-27713

Change 3063747 on 2016/07/25 by Bob.Tellez

	#Fortnite Fixed XB1 compile error due to use of DeviceDetails in XAudio2. Also removed a redundant #if XAUDIO_SUPPORTS_DEVICE_DETAILS

	#JIRA

Change 3063500 on 2016/07/25 by Bob.Tellez

	#UE4 Fixing static analysis warning about not checking the return value of CoInitialize. Also initializing DeviceEnumerator to nullptr in case CoCreateInstance fails.

Change 3063317 on 2016/07/25 by Lukasz.Furman

	fixed navlink deprecation in engine module, temporarily changed deprecation to private access since macro doesn't work with auto generated constructors
	#fortnite

Change 3063224 on 2016/07/25 by Bob.Tellez

	#UE4 Unshelved change from Nick.Darnell. This is the less-invasive version of 3062014.

	Avoid adding widgets to the hittest grid more than once.

Change 3063188 on 2016/07/25 by Lukasz.Furman

	removed all raw class pointers from link & area nav modifiers and replaced them with weak object pointers
	#jira FORT-27186

Change 3062338 on 2016/07/22 by Aaron.McLeran

	FORT-26470 Adding ability to stop sounds and switch audio engine into a no-sound mode when audio device is disabled/unplugged.

	#tests run game, disable or unplug audio device used by game, audio should stop gracefully without crashing

Change 3061806 on 2016/07/22 by Ben.Zeigler

	#jira FORT-27519 Change error from moving a non registered component to an ensure instead of a fatal crash, this error is very old and I'm not sure what would cause it, but it went off without giving us a stack

Change 3061790 on 2016/07/22 by Ben.Zeigler

	#jira FORT-26136 Stop a shipping game without blueprint guard enabled from printing useless stacks without an accompanying error message. This was slowing down shipping builds with no benefit
	Related to changes made on Orion in CL #2878992

Change 3060590 on 2016/07/21 by Mark.Satterthwaite

	Fix FORT-27340: Mac Metal cannot natively support PF_G8 + sRGB as not all Mac GPUs have single-channel sRGB formats (according to Apple) so we must manually pack & unpack to RGBA8_sRGB - the code to do this was missing from UpdateTexture2D.

Change 3060542 on 2016/07/21 by Bob.Tellez

	#UE4 Made SetIsEnabled and SetVisibility virtual.

Change 3058876 on 2016/07/20 by Aaron.McLeran

	FORT-25593 Mac crash when idling in zone with screen locked

	Adding logging when failing to update AuGraph and not asserting.

Change 3058653 on 2016/07/20 by Bob.Tellez

	#UE4 Now actually removing deprecated pins from non-blueprint graphs. Also MarkPendingKill now happens in UEdGraphNode's BeginDestroy instead of its destructor to ensure supporting code can safely access references to other UObjects.

Change 3058568 on 2016/07/20 by Bob.Tellez

	#UE4 Added an optional flag to IAssetRegistry::GetAssetByObjectPath to ignore in-memory assets for maxiumum performance.

Change 3058203 on 2016/07/20 by Bob.Tellez

	#UE4 Clearing pin links for fixed up BT nodes so they are not asymmetrical by the time the node gets destroyed, causing an ensure to fail. Also removing the replaced nodes so they are no longer saved in the package.

Change 3056767 on 2016/07/19 by Bob.Tellez

	#UE4 Speculative DetachLinker crash fix.

	#JIRA FORT-27335

Change 3056665 on 2016/07/19 by John.Abercrombie

	Fixed UPathFollowingComponent::HasReached not using the Goal's Radius when bUseNavAgentGoalLocation is false
	- When bUseNavAgentGoalLocation is true, we want to avoid using the Goal's location on the Nav Mesh, but the acceptability of a radius should be based on the Goal's radius

Change 3054368 on 2016/07/18 by Lina.Halper

	- moved removing notifies to end of montage event
	  - that way between blending out to terminate, it still can trigger notifies.

	#code review: Martin.Wilson, John.Abercrombie

Change 3054109 on 2016/07/18 by Bob.Tellez

	#UE4 Fixed a bug where IAssetRegistry::GetAllAssets would not return data about live objects when passing bIncludeOnlyOnDiskAssets = false.

Change 3053831 on 2016/07/18 by Lina.Halper

	#Anim montage recursive issue: Make sure to check valid before additive

	#code review: Bob.Tellez

Change 3052641 on 2016/07/15 by Bob.Tellez

	#UE4 Fix a crash in OpusAudioInfo when InSrcBufferData is null.

Change 3052601 on 2016/07/15 by Daniel.Broder

	EnvQueryInstanceBlueprintWrapper is now blueprintable, so you can make blueprints that allow more complex 'wrapper' behavior when using the blueprint node RunEQSQuery (on the EnvQueryManager).

	#ReleaseNoteAbove^^

	Also, made EEnvQueryStatus a blueprint type, which makes it much easier to work with in blueprints.

	#UE4 #ReleaseNote!

Change 3052201 on 2016/07/15 by Rob.Cannaday

	Fix for broken party state when timeout on receiving leave request response
	Execute delegate after marking the party in a disconnected state
	#jira FORT-25362

Change 3050944 on 2016/07/14 by Bob.Tellez

	#UE4 Fix an ensure that was incorrectly triggering when the number of hitches in a session is 0

Change 3050352 on 2016/07/14 by Olaf.Piesche

	#jira UE-32058

	Making sure owned pointer to CurrentMaterial is set to RenderMaterial if we choose default material because of missing flags for particle systems.

Change 3049049 on 2016/07/13 by Bob.Tellez

	#UE4 Fix an ensure and a crash in ParticleTrail2EmitterInstance for Ribbon particles.

	#JIRA FORT-27030

Change 3048186 on 2016/07/13 by John.Abercrombie

	Selecting Geometry trace mode will no longer project onto the nav mesh first in ProjectedPoints EQS generators

Change 3046531 on 2016/07/12 by Bob.Tellez

	#UE4 Added more information to an ensure about BeginPlay being called on an actor that has already begun play.

	#JIRA FORT-26683

Change 3046134 on 2016/07/12 by Ian.Fox

	#UE4, #OnlineSubSystem - Hotfix in the ExpirationDate field early so we can update the OGF plugin

Change 3045544 on 2016/07/11 by Bob.Tellez

	#UE4 Made Attribute fixup code only execute when loading the data from disk as it was intended.

Change 3045101 on 2016/07/11 by Fred.Kimberley

	Changed PostSerialize logic to always use the attribute data if it is valid. Updated the details customization to set the owner and name properties when the attribute is changed.

Change 3045035 on 2016/07/11 by John.Abercrombie

	UpdateMoveFocus will only clear the focus if the path following component is idle
	- Keeps the AI rotated in the correct direction when movements get paused

Change 3044883 on 2016/07/11 by Mark.Satterthwaite

	Avoid FORT-26879 - when rendering into the viewport back-buffer the scene-viewport sets a null render-target array which MetalRHI wasn't handing, so add the necessary branches to clear the render-target array in MetalStateCache.
	#jira FORT-26879

Change 3044819 on 2016/07/11 by Carlos.Cuello

	Setting LOCKED_REPLAY_VERSION to 0 so that replays have valid changelists associated with them in ReplayMGR

Change 3044683 on 2016/07/11 by Bob.Tellez

	#UE4 ActorPosition is now set to your AttachmentRootActor's position instead of your owning actor's position.

Change 3044581 on 2016/07/11 by Nick.Cooper

	#UE4 - Added bSuppressStackingCues to UGameplayEffect, to allow the option avoid sending a GameplayCue RPC for each instance of a stacking UGameplayEffect

	#jira FORT-23140

Change 3043726 on 2016/07/08 by Billy.Bramer

	- Add ability for custom UGameplayModMagnitudeCalculations to specify that they have gameplay-code dependencies external to the ability system that can invalidate them aside from just routine attribute capture
	   - UGameplayModMagnitudeCalculations can specify an external multicast delegate that the ability system component can bind to for notification of when the mod calculations are dirty and need to be refreshed
	   - Add advanced support for UGameplayModMagnitudeCalculations opting into allowing this feature to work on client machines as well; Advanced feature to really only be used by games utilizing network dormancy on attributes that they don't mind the client attempting to calculate (ones that won't have gameplay impact); Client-based feature cannot work in tandem with attribute capture

	- Rename FGameplayEffectModifierMagnitude::AttemptRecalculateMagnitudeFromDependentChange to AttemptRecalculateMagnitudeFromDependentAggregatorChange to alleviate possible confusion from the newly added support for external dependencies
	- Rename FActiveGameplayEffectsContainer::PreDestroy to Uninitialize and move its call site from the destructor of the owning ASC to UnitializeComponents, where it can have enough information to be useful
	- Misc ability system cleanup (fix typos, etc.)

Change 3043152 on 2016/07/08 by Daniel.Broder

	Re-enabled EQS details table on screen by default.  (This matches the actual description of the variable, which says that enabled is the default.  Also, we really need this as the default since those details are critical for debugging.)

	#UE4 #NoReleaseNotes

Change 3041765 on 2016/07/07 by John.Abercrombie

	Fixed basing whether the AI should turn or not by comparing the current desired rotation vs the last update's desired rotation
	- The AI should be turning based on whether or not the current desired rotation is different from the rotation of the Pawn

Change 3041664 on 2016/07/07 by Bob.Tellez

	#UE4 Removing UpdateActorPosition. This was not needed in a vast majority of use cases and was causing a crash due to multithreading issues during end of frame updates.

	#JIRA FORT-25983

Change 3040645 on 2016/07/06 by Bob.Tellez

	#UE4 Added a cvar to disable OpenGL support on Mac. If a mac that does not support Metal launches while this cvar is set to 1 then they will get a dialog box describing that they do not support metal and the process will close.

Change 3039969 on 2016/07/06 by Billy.Bramer

	- Fix for non-snapshotted, attribute-based modifiers potentially not replicating correctly
	- When dependency magnitude results in a magnitude recalculation, mark the active effect dirty and wake the owner from dormancy, as the client is incapable of recalculating the value properly

Change 3036256 on 2016/07/01 by Bob.Tellez

	#UE4 RequestExit(true) on Mac now exits without triggering exception handling, just like on Windows.

Change 3036173 on 2016/07/01 by Ben.Salem

	Get FTests running sequentially. And, actually, running at all in non-editor.
	Known issues: Filename lookup needs to be changed to use asset registry instead of packages in directory. Will be worked on next.

Change 3035551 on 2016/07/01 by John.Abercrombie

	Reworked use of the Montage pointer of the AnimNotifyEvent in UAnimInstance::OnMontageInstanceStopped based on Lina's feedback
	- CL 3034853 contained the original change

Change 3035152 on 2016/06/30 by Daniel.Broder

	Added new API function for DrawDebugSolidBox, which takes an FBox instead of a Center and Extent.  It also allows specifying a transform as well (but defaults to using the identity transform for convenience).

	#ReleaseNoteAbove

	The new version of DrawDebugSolidBox is more convenient and more efficient if you already have an FBox!  No need to calculate the Center and Extent just to use them to recalculate the Box.

	Made the previous two versions of DrawDebugSolidBox call to the new one that takes an FBox and FTransform.  This change keeps the implementation details more manageable for any future changes.

	Also, fixed typos in parameter names for DrawDebugSolidBox and DrawDebugBox versions where Extent was erroneously named "Box".

	NOTE: In the future, we should probably make the same changes to the DrawDebugBox API that were made for DrawDebugSolidBox, as well as similar changes for other shapes (such as DrawDebugSphere, Cylinder, etc.), which currently don't have versions that take the shape class directly/

	#UE4 #ReleaseNoteAtTop

Change 3034918 on 2016/06/30 by William.Ewen

	Updating Null RHI's max texture dimensions and max texture mip count to avoid a warning and match up with d3d11 and metal.

Change 3034853 on 2016/06/30 by John.Abercrombie

	When a Montage is stopped we send out any anim notify state end notifications related to the Montage, and remove it from the list

Change 3033507 on 2016/06/29 by Ben.Zeigler

	#jira UE-32651 Fix crash I had while auto saving a map with a reflection capture component. This has happened fairly often to licensees as well so we may want to merge it to a release branch

Change 3033413 on 2016/06/29 by Daniel.Wright

	Added DistanceFieldBias to StaticMesh BuildSettings for mesh distance fields
	* Useful for reducing self shadowing on meshes that have ambient animation

Change 3033343 on 2016/06/29 by Billy.Bramer

	- Fix typo in ability system: FMinimapReplicationTagCountMap should be FMinimalReplicationTagCountMap (it has nothing to do with minimaps!)

Change 3032888 on 2016/06/29 by Billy.Bramer

	- Add ability to base a gameplay effect modifier's magnitude off of the magnitude of an attribute evaluated only up to a certain channel when using attribute-based modifiers

Change 3031800 on 2016/06/28 by Jonathan.Lindquist

	new exr texture

Change 3030807 on 2016/06/28 by Lukasz.Furman

	added more debug logs for rare navmesh raycast crash
	#jira FORT-22373

Change 3030624 on 2016/06/28 by Lukasz.Furman

	switching navgraph to use FMetaNavMeshPath
	#fortnite

Change 3030002 on 2016/06/27 by Ben.Zeigler

	Fix crash I got in SGraphPin::OnDragEnter when the pin did not have an outer. GetOuter now calls the Unchecked version
	I'm not sure why it was allowed to be null here, but it was clearly supported on purpose before and was crashing with the pin changes.

Change 3029720 on 2016/06/27 by Ben.Zeigler

	Fix TextFilterTests to pass the parameters in the correct order for > operators, and add tests that actually verify this. The real use cases were correct, only the test was broken

Change 3029574 on 2016/06/27 by Bob.Tellez

	#UE4 Fixed a crash caused by attempting to render shadows while r.ShadowQuality was 0.

Change 3027275 on 2016/06/24 by Billy.Bramer

	- First pass of adding evaluation channel support to non-instant gameplay effects
	   - Evaluation channels allow for game-specific control over the order of modifier evaluation
	      - Channels evaluate in order, with the output of one channel acting as the base value/input into the next channel in sequential order
	      - Example: Sample Attribute: Base Value 100. Multiplicative Mod 1.1 in channel 0 and multplicative mod 1.1 in channel 1 will evaluate as ((100 * 1.1) * 1.1) instead of (100 * 1.2)
	   - By default, evaluation channels are disabled (everything evaluates at channel 0), but a game can opt into using channels via INI
	      - Game must specify bAllowGameplayModEvaluationChannels=true, as well as provide name aliases for the channels that the game is allowed to use via GameplayModEvaluationChannelAliases array
	      - Game can also specify the DefaultGameplayModEvaluationChannel via INI; Gameplay effect modifiers will default into that channel
	   - Evaluation channels show up per modifier (and per scoped modifier) in a new property on gameplay effects

	- Misc. clean-up and refactors within the ability system as a result of changes to support evaluation channels; Begin process of trying to remove heavy reliance on friend classes

Change 3022931 on 2016/06/22 by Nick.Cooper

	#UE4 - Prevent camera anims without an FOV track from making any modifications to the camera FOV

Change 3021845 on 2016/06/21 by Carlos.Cuello

	Fix for crash at startup on Mac, was asserting on !bPerformingOperation but there are codepaths where that wasn't being set to false at the end of an operation in failure cases.  Fixed up those codepaths and changed the check() to an ensure() so we can still track where these cases happen but won't affect our shipping build.

	#jira Fort-25978

Change 3021800 on 2016/06/21 by Lukasz.Furman

	adding function to query if navmesh was initialized in given radius
	#jira FORT-24487

Change 3021777 on 2016/06/21 by Martin.Mittring

	UE-31921 The sub surface profile shader seems to be incorrectly ignoring post processes
	content that used SkyLight OcclusionTint feature will look different and might need a retweak.
	a brighter (~ 3-4 times) and less vibrant color results in a similar look
	#code_review:Jonathan.Lindquist

[CL 3123852 by Bob Tellez in Main branch]
2016-09-13 18:15:38 -04:00

2359 lines
91 KiB
C#
Raw Blame History

// Copyright 1998-2016 Epic Games, Inc. All Rights Reserved.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using UnrealBuildTool;
using System.IO;
using System.Reflection;
namespace AutomationTool
{
[Help("targetplatform=PlatformName", "target platform for building, cooking and deployment (also -Platform)")]
[Help("servertargetplatform=PlatformName", "target platform for building, cooking and deployment of the dedicated server (also -ServerPlatform)")]
public class ProjectParams
{
#region Constructors
/// <summary>
/// Gets a parameter from the command line if it hasn't been specified in the constructor.
/// If the command line is not available, default value will be used.
/// </summary>
/// <param name="Command">Command to parse the command line for. Can be null.</param>
/// <param name="SpecifiedValue">Value specified in the constructor (or not)</param>
/// <param name="Default">Default value.</param>
/// <param name="ParamNames">Command line parameter names to parse.</param>
/// <returns>Parameter value.</returns>
bool GetParamValueIfNotSpecified(CommandUtils Command, bool? SpecifiedValue, bool Default, params string[] ParamNames)
{
if (SpecifiedValue.HasValue)
{
return SpecifiedValue.Value;
}
else if (Command != null)
{
foreach (var Param in ParamNames)
{
if (Command.ParseParam(Param))
{
return true;
}
}
}
return Default;
}
/// <summary>
/// Gets optional parameter from the command line if it hasn't been specified in the constructor.
/// If the command line is not available or the command has not been specified in the command line, default value will be used.
/// </summary>
/// <param name="Command">Command to parse the command line for. Can be null.</param>
/// <param name="SpecifiedValue">Value specified in the constructor (or not)</param>
/// <param name="Default">Default value.</param>
/// <param name="TrueParam">Name of a parameter that sets the value to 'true', for example: -clean</param>
/// <param name="FalseParam">Name of a parameter that sets the value to 'false', for example: -noclean</param>
/// <returns>Parameter value or default value if the paramater has not been specified</returns>
bool? GetOptionalParamValueIfNotSpecified(CommandUtils Command, bool? SpecifiedValue, bool? Default, string TrueParam, string FalseParam)
{
if (SpecifiedValue.HasValue)
{
return SpecifiedValue.Value;
}
else if (Command != null)
{
bool? Value = null;
if (!String.IsNullOrEmpty(TrueParam) && Command.ParseParam(TrueParam))
{
Value = true;
}
else if (!String.IsNullOrEmpty(FalseParam) && Command.ParseParam(FalseParam))
{
Value = false;
}
if (Value.HasValue)
{
return Value;
}
}
return Default;
}
/// <summary>
/// Gets a parameter value from the command line if it hasn't been specified in the constructor.
/// If the command line is not available, default value will be used.
/// </summary>
/// <param name="Command">Command to parse the command line for. Can be null.</param>
/// <param name="SpecifiedValue">Value specified in the constructor (or not)</param>
/// <param name="ParamName">Command line parameter name to parse.</param>
/// <param name="Default">Default value</param>
/// <param name="bTrimQuotes">If set, the leading and trailing quotes will be removed, e.g. instead of "/home/User Name" it will return /home/User Name</param>
/// <returns>Parameter value.</returns>
string ParseParamValueIfNotSpecified(CommandUtils Command, string SpecifiedValue, string ParamName, string Default = "", bool bTrimQuotes = false)
{
string Result = Default;
if (SpecifiedValue != null)
{
Result = SpecifiedValue;
}
else if (Command != null)
{
Result = Command.ParseParamValue(ParamName, Default);
}
return bTrimQuotes ? Result.Trim( new char[]{'\"'} ) : Result;
}
/// <summary>
/// Sets up platforms
/// </summary>
/// <param name="DependentPlatformMap">Set with a mapping from source->destination if specified on command line</param>
/// <param name="Command">The command line to parse</param>
/// <param name="OverrideTargetPlatforms">If passed use this always</param>
/// <param name="DefaultTargetPlatforms">Use this if nothing is passed on command line</param>
/// <param name="AllowPlatformParams">Allow raw -platform options</param>
/// <param name="PlatformParamNames">Possible -parameters to check for</param>
/// <returns>List of platforms parsed from the command line</returns>
private List<TargetPlatformDescriptor> SetupTargetPlatforms(ref Dictionary<TargetPlatformDescriptor, TargetPlatformDescriptor> DependentPlatformMap, CommandUtils Command, List<TargetPlatformDescriptor> OverrideTargetPlatforms, List<TargetPlatformDescriptor> DefaultTargetPlatforms, bool AllowPlatformParams, params string[] PlatformParamNames)
{
List<TargetPlatformDescriptor> TargetPlatforms = null;
if (CommandUtils.IsNullOrEmpty(OverrideTargetPlatforms))
{
if (Command != null)
{
// Parse the command line, we support the following params:
// -'PlatformParamNames[n]'=Platform_1+Platform_2+...+Platform_k
// or (if AllowPlatformParams is true)
// -Platform_1 -Platform_2 ... -Platform_k
string CmdLinePlatform = null;
foreach (var ParamName in PlatformParamNames)
{
CmdLinePlatform = Command.ParseParamValue(ParamName);
if (!String.IsNullOrEmpty(CmdLinePlatform))
{
break;
}
}
List<string> CookFlavors = null;
{
string CmdLineCookFlavor = Command.ParseParamValue("cookflavor");
if (!String.IsNullOrEmpty(CmdLineCookFlavor))
{
CookFlavors = new List<string>(CmdLineCookFlavor.Split('+'));
}
}
if (!String.IsNullOrEmpty(CmdLinePlatform))
{
// Get all platforms from the param value: Platform_1+Platform_2+...+Platform_k
TargetPlatforms = new List<TargetPlatformDescriptor>();
var PlatformNames = new List<string>(CmdLinePlatform.Split('+'));
foreach (var PlatformName in PlatformNames)
{
// Look for dependent platforms, Source_1.Dependent_1+Source_2.Dependent_2+Standalone_3
var SubPlatformNames = new List<string>(PlatformName.Split('.'));
foreach (var SubPlatformName in SubPlatformNames)
{
UnrealTargetPlatform NewPlatformType = (UnrealTargetPlatform)Enum.Parse(typeof(UnrealTargetPlatform), SubPlatformName, true);
// generate all valid platform descriptions for this platform type + cook flavors
List<TargetPlatformDescriptor> PlatformDescriptors = Platform.GetValidTargetPlatforms(NewPlatformType, CookFlavors);
TargetPlatforms.AddRange(PlatformDescriptors);
if (SubPlatformName != SubPlatformNames[0])
{
// This is not supported with cook flavors
if (!CommandUtils.IsNullOrEmpty(CookFlavors))
{
throw new AutomationException("Cook flavors are not supported for dependent platforms!");
}
// We're a dependent platform so add ourselves to the map, pointing to the first element in the list
UnrealTargetPlatform FirstPlatformType = (UnrealTargetPlatform)Enum.Parse(typeof(UnrealTargetPlatform), SubPlatformNames[0], true);
DependentPlatformMap.Add(new TargetPlatformDescriptor(NewPlatformType), new TargetPlatformDescriptor(FirstPlatformType));
}
}
}
}
else if (AllowPlatformParams)
{
// Look up platform names in the command line: -Platform_1 -Platform_2 ... -Platform_k
TargetPlatforms = new List<TargetPlatformDescriptor>();
foreach (UnrealTargetPlatform PlatType in Enum.GetValues(typeof(UnrealTargetPlatform)))
{
if (PlatType != UnrealTargetPlatform.Unknown)
{
if (Command.ParseParam(PlatType.ToString()))
{
List<TargetPlatformDescriptor> PlatformDescriptors = Platform.GetValidTargetPlatforms(PlatType, CookFlavors);
TargetPlatforms.AddRange(PlatformDescriptors);
}
}
}
}
}
}
else
{
TargetPlatforms = OverrideTargetPlatforms;
}
if (CommandUtils.IsNullOrEmpty(TargetPlatforms))
{
// Revert to single default platform - the current platform we're running
TargetPlatforms = DefaultTargetPlatforms;
}
return TargetPlatforms;
}
public ProjectParams(ProjectParams InParams)
{
//
//// Use this.Name with properties and fields!
//
this.RawProjectPath = InParams.RawProjectPath;
this.MapsToCook = InParams.MapsToCook;
this.DirectoriesToCook = InParams.DirectoriesToCook;
this.InternationalizationPreset = InParams.InternationalizationPreset;
this.CulturesToCook = InParams.CulturesToCook;
this.BasedOnReleaseVersion = InParams.BasedOnReleaseVersion;
this.CreateReleaseVersion = InParams.CreateReleaseVersion;
this.GeneratePatch = InParams.GeneratePatch;
this.DLCName = InParams.DLCName;
this.DLCIncludeEngineContent = InParams.DLCIncludeEngineContent;
this.DiffCookedContentPath = InParams.DiffCookedContentPath;
this.NewCook = InParams.NewCook;
this.OldCook = InParams.OldCook;
this.AdditionalCookerOptions = InParams.AdditionalCookerOptions;
this.ClientCookedTargets = InParams.ClientCookedTargets;
this.ServerCookedTargets = InParams.ServerCookedTargets;
this.EditorTargets = InParams.EditorTargets;
this.ProgramTargets = InParams.ProgramTargets;
this.ClientTargetPlatforms = InParams.ClientTargetPlatforms;
this.ClientDependentPlatformMap = InParams.ClientDependentPlatformMap;
this.ServerTargetPlatforms = InParams.ServerTargetPlatforms;
this.ServerDependentPlatformMap = InParams.ServerDependentPlatformMap;
this.Build = InParams.Build;
this.Run = InParams.Run;
this.Cook = InParams.Cook;
this.IterativeCooking = InParams.IterativeCooking;
this.CookAll = InParams.CookAll;
this.CookPartialGC = InParams.CookPartialGC;
this.CookMapsOnly = InParams.CookMapsOnly;
this.SkipCook = InParams.SkipCook;
this.SkipCookOnTheFly = InParams.SkipCookOnTheFly;
this.Prebuilt = InParams.Prebuilt;
this.RunTimeoutSeconds = InParams.RunTimeoutSeconds;
this.Clean = InParams.Clean;
this.Pak = InParams.Pak;
this.SignPak = InParams.SignPak;
this.SignedPak = InParams.SignedPak;
this.SkipPak = InParams.SkipPak;
this.NoXGE = InParams.NoXGE;
this.CookOnTheFly = InParams.CookOnTheFly;
this.CookOnTheFlyStreaming = InParams.CookOnTheFlyStreaming;
this.UnversionedCookedContent = InParams.UnversionedCookedContent;
this.EncryptIniFiles = InParams.EncryptIniFiles;
this.SkipCookingEditorContent = InParams.SkipCookingEditorContent;
this.NumCookersToSpawn = InParams.NumCookersToSpawn;
this.FileServer = InParams.FileServer;
this.DedicatedServer = InParams.DedicatedServer;
this.Client = InParams.Client;
this.NoClient = InParams.NoClient;
this.LogWindow = InParams.LogWindow;
this.Stage = InParams.Stage;
this.SkipStage = InParams.SkipStage;
this.StageDirectoryParam = InParams.StageDirectoryParam;
this.Manifests = InParams.Manifests;
this.CreateChunkInstall = InParams.CreateChunkInstall;
this.UE4Exe = InParams.UE4Exe;
this.NoDebugInfo = InParams.NoDebugInfo;
this.NoCleanStage = InParams.NoCleanStage;
this.MapToRun = InParams.MapToRun;
this.AdditionalServerMapParams = InParams.AdditionalServerMapParams;
this.Foreign = InParams.Foreign;
this.ForeignCode = InParams.ForeignCode;
this.StageCommandline = InParams.StageCommandline;
this.BundleName = InParams.BundleName;
this.RunCommandline = InParams.RunCommandline;
this.ServerCommandline = InParams.ServerCommandline;
this.Package = InParams.Package;
this.Deploy = InParams.Deploy;
this.IterativeDeploy = InParams.IterativeDeploy;
this.IgnoreCookErrors = InParams.IgnoreCookErrors;
this.FastCook = InParams.FastCook;
this.Devices = InParams.Devices;
this.DeviceNames = InParams.DeviceNames;
this.ServerDevice = InParams.ServerDevice;
this.NullRHI = InParams.NullRHI;
this.FakeClient = InParams.FakeClient;
this.EditorTest = InParams.EditorTest;
this.RunAutomationTests = InParams.RunAutomationTests;
this.RunAutomationTest = InParams.RunAutomationTest;
this.CrashIndex = InParams.CrashIndex;
this.Port = InParams.Port;
this.SkipServer = InParams.SkipServer;
this.Unattended = InParams.Unattended;
this.ServerDeviceAddress = InParams.ServerDeviceAddress;
this.DeviceUsername = InParams.DeviceUsername;
this.DevicePassword = InParams.DevicePassword;
this.CrashReporter = InParams.CrashReporter;
this.ClientConfigsToBuild = InParams.ClientConfigsToBuild;
this.ServerConfigsToBuild = InParams.ServerConfigsToBuild;
this.NumClients = InParams.NumClients;
this.Compressed = InParams.Compressed;
this.UseDebugParamForEditorExe = InParams.UseDebugParamForEditorExe;
this.bUsesSteam = InParams.bUsesSteam;
this.bUsesCEF3 = InParams.bUsesCEF3;
this.bUsesSlate = InParams.bUsesSlate;
this.bUsesSlateEditorStyle = InParams.bUsesSlateEditorStyle;
this.bDebugBuildsActuallyUseDebugCRT = InParams.bDebugBuildsActuallyUseDebugCRT;
this.Archive = InParams.Archive;
this.ArchiveDirectoryParam = InParams.ArchiveDirectoryParam;
this.ArchiveMetaData = InParams.ArchiveMetaData;
this.CreateAppBundle = InParams.CreateAppBundle;
this.Distribution = InParams.Distribution;
this.Prereqs = InParams.Prereqs;
this.AppLocalDirectory = InParams.AppLocalDirectory;
this.NoBootstrapExe = InParams.NoBootstrapExe;
this.Prebuilt = InParams.Prebuilt;
this.RunTimeoutSeconds = InParams.RunTimeoutSeconds;
this.bIsCodeBasedProject = InParams.bIsCodeBasedProject;
this.bCodeSign = InParams.bCodeSign;
this.TitleID = InParams.TitleID;
this.bTreatNonShippingBinariesAsDebugFiles = InParams.bTreatNonShippingBinariesAsDebugFiles;
this.RunAssetNativization = InParams.RunAssetNativization;
}
/// <summary>
/// Constructor. Be sure to use this.ParamName to set the actual property name as parameter names and property names
/// overlap here.
/// If a parameter value is not set, it will be parsed from the command line; if the command is null, the default value will be used.
/// </summary>
public ProjectParams(
FileReference RawProjectPath,
CommandUtils Command = null,
string Device = null,
string MapToRun = null,
string AdditionalServerMapParams = null,
ParamList<string> Port = null,
string RunCommandline = null,
string StageCommandline = null,
string BundleName = null,
string StageDirectoryParam = null,
string UE4Exe = null,
string SignPak = null,
List<UnrealTargetConfiguration> ClientConfigsToBuild = null,
List<UnrealTargetConfiguration> ServerConfigsToBuild = null,
ParamList<string> MapsToCook = null,
ParamList<string> DirectoriesToCook = null,
string InternationalizationPreset = null,
ParamList<string> CulturesToCook = null,
ParamList<string> ClientCookedTargets = null,
ParamList<string> EditorTargets = null,
ParamList<string> ServerCookedTargets = null,
List<TargetPlatformDescriptor> ClientTargetPlatforms = null,
Dictionary<TargetPlatformDescriptor, TargetPlatformDescriptor> ClientDependentPlatformMap = null,
List<TargetPlatformDescriptor> ServerTargetPlatforms = null,
Dictionary<TargetPlatformDescriptor, TargetPlatformDescriptor> ServerDependentPlatformMap = null,
bool? Build = null,
bool? Cook = null,
bool? Run = null,
bool? SkipServer = null,
bool? Clean = null,
bool? Compressed = null,
bool? UseDebugParamForEditorExe = null,
bool? IterativeCooking = null,
bool? CookAll = null,
bool? CookPartialGC = null,
bool? CookMapsOnly = null,
bool? CookOnTheFly = null,
bool? CookOnTheFlyStreaming = null,
bool? UnversionedCookedContent = null,
bool? EncryptIniFiles = null,
bool? SkipCookingEditorContent = null,
int? NumCookersToSpawn = null,
string AdditionalCookerOptions = null,
string BasedOnReleaseVersion = null,
string CreateReleaseVersion = null,
string CreateReleaseVersionBasePath = null,
string BasedOnReleaseVersionBasePath = null,
bool? GeneratePatch = null,
string DLCName = null,
string DiffCookedContentPath = null,
bool? DLCIncludeEngineContent = null,
bool? NewCook = null,
bool? OldCook = null,
bool? CrashReporter = null,
bool? DedicatedServer = null,
bool? Client = null,
bool? Deploy = null,
bool? FileServer = null,
bool? Foreign = null,
bool? ForeignCode = null,
bool? LogWindow = null,
bool? NoCleanStage = null,
bool? NoClient = null,
bool? NoDebugInfo = null,
bool? NoXGE = null,
bool? Package = null,
bool? Pak = null,
bool? Prereqs = null,
string AppLocalDirectory = null,
bool? NoBootstrapExe = null,
bool? SignedPak = null,
bool? NullRHI = null,
bool? FakeClient = null,
bool? EditorTest = null,
bool? RunAutomationTests = null,
string RunAutomationTest = null,
int? CrashIndex = null,
bool? SkipCook = null,
bool? SkipCookOnTheFly = null,
bool? SkipPak = null,
bool? SkipStage = null,
bool? Stage = null,
bool? Manifests = null,
bool? CreateChunkInstall = null,
bool? Unattended = null,
int? NumClients = null,
bool? Archive = null,
string ArchiveDirectoryParam = null,
bool? ArchiveMetaData = null,
bool? CreateAppBundle = null,
ParamList<string> ProgramTargets = null,
bool? Distribution = null,
bool? Prebuilt = null,
int? RunTimeoutSeconds = null,
string SpecifiedArchitecture = null,
bool? IterativeDeploy = null,
bool? FastCook = null,
bool? IgnoreCookErrors = null,
bool? RunAssetNativization = null,
bool? CodeSign = null,
bool? TreatNonShippingBinariesAsDebugFiles = null,
string Provision = null,
string Certificate = null,
ParamList<string> InMapsToRebuildLightMaps = null,
ParamList<string> TitleID = null
)
{
//
//// Use this.Name with properties and fields!
//
this.RawProjectPath = RawProjectPath;
if (DirectoriesToCook != null)
{
this.DirectoriesToCook = DirectoriesToCook;
}
this.InternationalizationPreset = ParseParamValueIfNotSpecified(Command, InternationalizationPreset, "i18npreset");
// If not specified in parameters, check commandline.
if (CulturesToCook == null)
{
if (Command != null)
{
var CookCulturesString = Command.ParseParamValue("CookCultures");
if (CookCulturesString != null)
{
this.CulturesToCook = new ParamList<string>(CookCulturesString.Split(','));
}
}
}
else
{
this.CulturesToCook = CulturesToCook;
}
if (ClientCookedTargets != null)
{
this.ClientCookedTargets = ClientCookedTargets;
}
if (ServerCookedTargets != null)
{
this.ServerCookedTargets = ServerCookedTargets;
}
if (EditorTargets != null)
{
this.EditorTargets = EditorTargets;
}
if (ProgramTargets != null)
{
this.ProgramTargets = ProgramTargets;
}
// Parse command line params for client platforms "-TargetPlatform=Win64+Mac", "-Platform=Win64+Mac" and also "-Win64", "-Mac" etc.
if (ClientDependentPlatformMap != null)
{
this.ClientDependentPlatformMap = ClientDependentPlatformMap;
}
List<TargetPlatformDescriptor> DefaultTargetPlatforms = new ParamList<TargetPlatformDescriptor>(new TargetPlatformDescriptor(HostPlatform.Current.HostEditorPlatform));
this.ClientTargetPlatforms = SetupTargetPlatforms(ref this.ClientDependentPlatformMap, Command, ClientTargetPlatforms, DefaultTargetPlatforms, true, "TargetPlatform", "Platform");
// Parse command line params for server platforms "-ServerTargetPlatform=Win64+Mac", "-ServerPlatform=Win64+Mac". "-Win64" etc is not allowed here
if (ServerDependentPlatformMap != null)
{
this.ServerDependentPlatformMap = ServerDependentPlatformMap;
}
this.ServerTargetPlatforms = SetupTargetPlatforms(ref this.ServerDependentPlatformMap, Command, ServerTargetPlatforms, this.ClientTargetPlatforms, false, "ServerTargetPlatform", "ServerPlatform");
this.Build = GetParamValueIfNotSpecified(Command, Build, this.Build, "build");
this.Run = GetParamValueIfNotSpecified(Command, Run, this.Run, "run");
this.Cook = GetParamValueIfNotSpecified(Command, Cook, this.Cook, "cook");
this.NewCook = GetParamValueIfNotSpecified(Command, NewCook, this.NewCook, "NewCook");
this.OldCook = GetParamValueIfNotSpecified(Command, OldCook, this.OldCook, "OldCook");
this.CreateReleaseVersionBasePath = ParseParamValueIfNotSpecified(Command, CreateReleaseVersionBasePath, "createreleaseversionroot", String.Empty);
this.BasedOnReleaseVersionBasePath = ParseParamValueIfNotSpecified(Command, BasedOnReleaseVersionBasePath, "basedonreleaseversionroot", String.Empty);
this.CreateReleaseVersion = ParseParamValueIfNotSpecified(Command, CreateReleaseVersion, "createreleaseversion", String.Empty);
this.BasedOnReleaseVersion = ParseParamValueIfNotSpecified(Command, BasedOnReleaseVersion, "basedonreleaseversion", String.Empty);
this.GeneratePatch = GetParamValueIfNotSpecified(Command, GeneratePatch, this.GeneratePatch, "GeneratePatch");
this.AdditionalCookerOptions = ParseParamValueIfNotSpecified(Command, AdditionalCookerOptions, "AdditionalCookerOptions", String.Empty);
this.DLCName = ParseParamValueIfNotSpecified(Command, DLCName, "DLCName", String.Empty);
this.DiffCookedContentPath = ParseParamValueIfNotSpecified(Command, DiffCookedContentPath, "DiffCookedContentPath", String.Empty);
this.DLCIncludeEngineContent = GetParamValueIfNotSpecified(Command, DLCIncludeEngineContent, this.DLCIncludeEngineContent, "DLCIncludeEngineContent");
this.SkipCook = GetParamValueIfNotSpecified(Command, SkipCook, this.SkipCook, "skipcook");
if (this.SkipCook)
{
this.Cook = true;
}
this.Clean = GetOptionalParamValueIfNotSpecified(Command, Clean, this.Clean, "clean", null);
this.SignPak = ParseParamValueIfNotSpecified(Command, SignPak, "signpak", String.Empty);
this.SignedPak = !String.IsNullOrEmpty(this.SignPak) || GetParamValueIfNotSpecified(Command, SignedPak, this.SignedPak, "signedpak");
if (string.IsNullOrEmpty(this.SignPak))
{
this.SignPak = Path.Combine(RawProjectPath.Directory.FullName, @"Build\NoRedist\Keys.txt");
if (!File.Exists(this.SignPak))
{
this.SignPak = null;
}
}
this.Pak = GetParamValueIfNotSpecified(Command, Pak, this.Pak, "pak");
this.SkipPak = GetParamValueIfNotSpecified(Command, SkipPak, this.SkipPak, "skippak");
if (this.SkipPak)
{
this.Pak = true;
}
this.NoXGE = GetParamValueIfNotSpecified(Command, NoXGE, this.NoXGE, "noxge");
this.CookOnTheFly = GetParamValueIfNotSpecified(Command, CookOnTheFly, this.CookOnTheFly, "cookonthefly");
if (this.CookOnTheFly && this.SkipCook)
{
this.Cook = false;
}
this.CookOnTheFlyStreaming = GetParamValueIfNotSpecified(Command, CookOnTheFlyStreaming, this.CookOnTheFlyStreaming, "cookontheflystreaming");
this.UnversionedCookedContent = GetParamValueIfNotSpecified(Command, UnversionedCookedContent, this.UnversionedCookedContent, "UnversionedCookedContent");
this.EncryptIniFiles = GetParamValueIfNotSpecified(Command, EncryptIniFiles, this.EncryptIniFiles, "EncryptIniFiles");
this.SkipCookingEditorContent = GetParamValueIfNotSpecified(Command, SkipCookingEditorContent, this.SkipCookingEditorContent, "SkipCookingEditorContent");
if (NumCookersToSpawn.HasValue)
{
this.NumCookersToSpawn = NumCookersToSpawn.Value;
}
else if (Command != null)
{
this.NumCookersToSpawn = Command.ParseParamInt("NumCookersToSpawn");
}
this.Compressed = GetParamValueIfNotSpecified(Command, Compressed, this.Compressed, "compressed");
this.UseDebugParamForEditorExe = GetParamValueIfNotSpecified(Command, UseDebugParamForEditorExe, this.UseDebugParamForEditorExe, "UseDebugParamForEditorExe");
this.IterativeCooking = GetParamValueIfNotSpecified(Command, IterativeCooking, this.IterativeCooking, new string[] { "iterativecooking", "iterate" } );
this.SkipCookOnTheFly = GetParamValueIfNotSpecified(Command, SkipCookOnTheFly, this.SkipCookOnTheFly, "skipcookonthefly");
this.CookAll = GetParamValueIfNotSpecified(Command, CookAll, this.CookAll, "CookAll");
this.CookPartialGC = GetParamValueIfNotSpecified(Command, CookPartialGC, this.CookPartialGC, "CookPartialGC");
this.CookMapsOnly = GetParamValueIfNotSpecified(Command, CookMapsOnly, this.CookMapsOnly, "CookMapsOnly");
this.FileServer = GetParamValueIfNotSpecified(Command, FileServer, this.FileServer, "fileserver");
this.DedicatedServer = GetParamValueIfNotSpecified(Command, DedicatedServer, this.DedicatedServer, "dedicatedserver", "server");
this.Client = GetParamValueIfNotSpecified(Command, Client, this.Client, "client");
/*if( this.Client )
{
this.DedicatedServer = true;
}*/
this.NoClient = GetParamValueIfNotSpecified(Command, NoClient, this.NoClient, "noclient");
this.LogWindow = GetParamValueIfNotSpecified(Command, LogWindow, this.LogWindow, "logwindow");
this.Stage = GetParamValueIfNotSpecified(Command, Stage, this.Stage, "stage");
this.SkipStage = GetParamValueIfNotSpecified(Command, SkipStage, this.SkipStage, "skipstage");
if (this.SkipStage)
{
this.Stage = true;
}
this.StageDirectoryParam = ParseParamValueIfNotSpecified(Command, StageDirectoryParam, "stagingdirectory", String.Empty, true);
this.bCodeSign = GetParamValueIfNotSpecified(Command, CodeSign, CommandUtils.IsBuildMachine, "CodeSign");
this.bTreatNonShippingBinariesAsDebugFiles = GetParamValueIfNotSpecified(Command, TreatNonShippingBinariesAsDebugFiles, false, "TreatNonShippingBinariesAsDebugFiles");
this.Manifests = GetParamValueIfNotSpecified(Command, Manifests, this.Manifests, "manifests");
this.CreateChunkInstall = GetParamValueIfNotSpecified(Command, CreateChunkInstall, this.CreateChunkInstall, "createchunkinstall");
this.ChunkInstallDirectory = ParseParamValueIfNotSpecified(Command, ChunkInstallDirectory, "chunkinstalldirectory", String.Empty, true);
this.ChunkInstallVersionString = ParseParamValueIfNotSpecified(Command, ChunkInstallVersionString, "chunkinstallversion", String.Empty, true);
this.Archive = GetParamValueIfNotSpecified(Command, Archive, this.Archive, "archive");
this.ArchiveDirectoryParam = ParseParamValueIfNotSpecified(Command, ArchiveDirectoryParam, "archivedirectory", String.Empty, true);
this.ArchiveMetaData = GetParamValueIfNotSpecified(Command, ArchiveMetaData, this.ArchiveMetaData, "archivemetadata");
this.CreateAppBundle = GetParamValueIfNotSpecified(Command, CreateAppBundle, true, "createappbundle");
this.Distribution = GetParamValueIfNotSpecified(Command, Distribution, this.Distribution, "distribution");
this.Prereqs = GetParamValueIfNotSpecified(Command, Prereqs, this.Prereqs, "prereqs");
this.AppLocalDirectory = ParseParamValueIfNotSpecified(Command, AppLocalDirectory, "applocaldirectory", String.Empty, true);
this.NoBootstrapExe = GetParamValueIfNotSpecified(Command, NoBootstrapExe, this.NoBootstrapExe, "nobootstrapexe");
this.Prebuilt = GetParamValueIfNotSpecified(Command, Prebuilt, this.Prebuilt, "prebuilt");
if (this.Prebuilt)
{
this.SkipCook = true;
/*this.SkipPak = true;
this.SkipStage = true;
this.Pak = true;
this.Stage = true;*/
this.Cook = true;
this.Archive = true;
this.Deploy = true;
this.Run = true;
//this.StageDirectoryParam = this.PrebuiltDir;
}
this.NoDebugInfo = GetParamValueIfNotSpecified(Command, NoDebugInfo, this.NoDebugInfo, "nodebuginfo");
this.NoCleanStage = GetParamValueIfNotSpecified(Command, NoCleanStage, this.NoCleanStage, "nocleanstage");
this.MapToRun = ParseParamValueIfNotSpecified(Command, MapToRun, "map", String.Empty);
this.AdditionalServerMapParams = ParseParamValueIfNotSpecified(Command, AdditionalServerMapParams, "AdditionalServerMapParams", String.Empty);
this.Foreign = GetParamValueIfNotSpecified(Command, Foreign, this.Foreign, "foreign");
this.ForeignCode = GetParamValueIfNotSpecified(Command, ForeignCode, this.ForeignCode, "foreigncode");
this.StageCommandline = ParseParamValueIfNotSpecified(Command, StageCommandline, "cmdline");
this.BundleName = ParseParamValueIfNotSpecified(Command, BundleName, "bundlename");
this.RunCommandline = ParseParamValueIfNotSpecified(Command, RunCommandline, "addcmdline");
this.RunCommandline = this.RunCommandline.Replace('\'', '\"'); // replace any single quotes with double quotes
this.ServerCommandline = ParseParamValueIfNotSpecified(Command, ServerCommandline, "servercmdline");
this.ServerCommandline = this.ServerCommandline.Replace('\'', '\"'); // replace any single quotes with double quotes
this.Package = GetParamValueIfNotSpecified(Command, Package, this.Package, "package");
this.Deploy = GetParamValueIfNotSpecified(Command, Deploy, this.Deploy, "deploy");
this.IterativeDeploy = GetParamValueIfNotSpecified(Command, IterativeDeploy, this.IterativeDeploy, new string[] {"iterativedeploy", "iterate" } );
this.FastCook = GetParamValueIfNotSpecified(Command, FastCook, this.FastCook, "FastCook");
this.IgnoreCookErrors = GetParamValueIfNotSpecified(Command, IgnoreCookErrors, this.IgnoreCookErrors, "IgnoreCookErrors");
this.RunAssetNativization = GetParamValueIfNotSpecified(Command, RunAssetNativization, this.RunAssetNativization, "nativizeAssets");
string DeviceString = ParseParamValueIfNotSpecified(Command, Device, "device", String.Empty).Trim(new char[] { '\"' });
if(DeviceString == "")
{
this.Devices = new ParamList<string>("");
this.DeviceNames = new ParamList<string>("");
}
else
{
this.Devices = new ParamList<string>(DeviceString.Split('+'));
this.DeviceNames = new ParamList<string>();
foreach (var d in this.Devices)
{
// strip the platform prefix the specified device.
if (d.Contains("@"))
{
this.DeviceNames.Add(d.Substring(d.IndexOf("@") + 1));
}
else
{
this.DeviceNames.Add(d);
}
}
}
this.Provision = ParseParamValueIfNotSpecified(Command, Provision, "provision", String.Empty, true);
this.Certificate = ParseParamValueIfNotSpecified(Command, Certificate, "certificate", String.Empty, true);
this.ServerDevice = ParseParamValueIfNotSpecified(Command, ServerDevice, "serverdevice", this.Devices.Count > 0 ? this.Devices[0] : "");
this.NullRHI = GetParamValueIfNotSpecified(Command, NullRHI, this.NullRHI, "nullrhi");
this.FakeClient = GetParamValueIfNotSpecified(Command, FakeClient, this.FakeClient, "fakeclient");
this.EditorTest = GetParamValueIfNotSpecified(Command, EditorTest, this.EditorTest, "editortest");
this.RunAutomationTest = ParseParamValueIfNotSpecified(Command, RunAutomationTest, "RunAutomationTest");
this.RunAutomationTests = this.RunAutomationTest != "" || GetParamValueIfNotSpecified(Command, RunAutomationTests, this.RunAutomationTests, "RunAutomationTests");
this.SkipServer = GetParamValueIfNotSpecified(Command, SkipServer, this.SkipServer, "skipserver");
this.UE4Exe = ParseParamValueIfNotSpecified(Command, UE4Exe, "ue4exe", "UE4Editor-Cmd.exe");
this.Unattended = GetParamValueIfNotSpecified(Command, Unattended, this.Unattended, "unattended");
this.DeviceUsername = ParseParamValueIfNotSpecified(Command, DeviceUsername, "deviceuser", String.Empty);
this.DevicePassword = ParseParamValueIfNotSpecified(Command, DevicePassword, "devicepass", String.Empty);
this.CrashReporter = GetParamValueIfNotSpecified(Command, CrashReporter, this.CrashReporter, "crashreporter");
this.SpecifiedArchitecture = ParseParamValueIfNotSpecified(Command, SpecifiedArchitecture, "specifiedarchitecture", String.Empty);
if (ClientConfigsToBuild == null)
{
if (Command != null)
{
var ClientConfig = Command.ParseParamValue("clientconfig");
if (ClientConfig == null)
ClientConfig = Command.ParseParamValue("config");
if (ClientConfig != null)
{
this.ClientConfigsToBuild = new List<UnrealTargetConfiguration>();
var Configs = new ParamList<string>(ClientConfig.Split('+'));
foreach (var ConfigName in Configs)
{
this.ClientConfigsToBuild.Add((UnrealTargetConfiguration)Enum.Parse(typeof(UnrealTargetConfiguration), ConfigName, true));
}
}
}
}
else
{
this.ClientConfigsToBuild = ClientConfigsToBuild;
}
if (Port == null)
{
if( Command != null )
{
this.Port = new ParamList<string>();
var PortString = Command.ParseParamValue("port");
if (String.IsNullOrEmpty(PortString) == false)
{
var Ports = new ParamList<string>(PortString.Split('+'));
foreach (var P in Ports)
{
this.Port.Add(P);
}
}
}
}
else
{
this.Port = Port;
}
if (MapsToCook == null)
{
if (Command != null)
{
this.MapsToCook = new ParamList<string>();
var MapsString = Command.ParseParamValue("MapsToCook");
if (String.IsNullOrEmpty(MapsString) == false)
{
var MapNames = new ParamList<string>(MapsString.Split('+'));
foreach ( var M in MapNames )
{
this.MapsToCook.Add( M );
}
}
}
}
else
{
this.MapsToCook = MapsToCook;
}
if (String.IsNullOrEmpty(this.MapToRun) == false)
{
this.MapsToCook.Add(this.MapToRun);
}
if (InMapsToRebuildLightMaps == null)
{
if (Command != null)
{
this.MapsToRebuildLightMaps = new ParamList<string>();
var MapsString = Command.ParseParamValue("MapsToRebuildLightMaps");
if (String.IsNullOrEmpty(MapsString) == false)
{
var MapNames = new ParamList<string>(MapsString.Split('+'));
foreach (var M in MapNames)
{
this.MapsToRebuildLightMaps.Add(M);
}
}
}
}
else
{
this.MapsToRebuildLightMaps = InMapsToRebuildLightMaps;
}
if (TitleID == null)
{
if (Command != null)
{
this.TitleID = new ParamList<string>();
var TitleString = Command.ParseParamValue("TitleID");
if (String.IsNullOrEmpty(TitleString) == false)
{
var TitleIDs = new ParamList<string>(TitleString.Split('+'));
foreach (var T in TitleIDs)
{
this.TitleID.Add(T);
}
}
}
}
else
{
this.TitleID = TitleID;
}
if (ServerConfigsToBuild == null)
{
if (Command != null)
{
var ServerConfig = Command.ParseParamValue("serverconfig");
if (ServerConfig == null)
ServerConfig = Command.ParseParamValue("config");
if (ServerConfig != null)
{
this.ServerConfigsToBuild = new List<UnrealTargetConfiguration>();
var Configs = new ParamList<string>(ServerConfig.Split('+'));
foreach (var ConfigName in Configs)
{
this.ServerConfigsToBuild.Add((UnrealTargetConfiguration)Enum.Parse(typeof(UnrealTargetConfiguration), ConfigName, true));
}
}
}
}
else
{
this.ServerConfigsToBuild = ServerConfigsToBuild;
}
if (NumClients.HasValue)
{
this.NumClients = NumClients.Value;
}
else if (Command != null)
{
this.NumClients = Command.ParseParamInt("numclients");
}
if (CrashIndex.HasValue)
{
this.CrashIndex = CrashIndex.Value;
}
else if (Command != null)
{
this.CrashIndex = Command.ParseParamInt("CrashIndex");
}
if (RunTimeoutSeconds.HasValue)
{
this.RunTimeoutSeconds = RunTimeoutSeconds.Value;
}
else if (Command != null)
{
this.RunTimeoutSeconds = Command.ParseParamInt("runtimeoutseconds");
}
AutodetectSettings(false);
ValidateAndLog();
}
#endregion
#region Shared
/// <summary>
/// Shared: Full path to the .uproject file
/// </summary>
public FileReference RawProjectPath { private set; get; }
/// <summary>
/// Shared: The current project is a foreign project, commandline: -foreign
/// </summary>
[Help("foreign", "Generate a foreign uproject from blankproject and use that")]
public bool Foreign { private set; get; }
/// <summary>
/// Shared: The current project is a foreign project, commandline: -foreign
/// </summary>
[Help("foreigncode", "Generate a foreign code uproject from platformergame and use that")]
public bool ForeignCode { private set; get; }
/// <summary>
/// Shared: true if we should build crash reporter
/// </summary>
[Help("CrashReporter", "true if we should build crash reporter")]
public bool CrashReporter { private set; get; }
/// <summary>
/// Shared: Determines if the build is going to use cooked data, commandline: -cook, -cookonthefly
/// </summary>
[Help("cook, -cookonthefly", "Determines if the build is going to use cooked data")]
public bool Cook { private set; get; }
/// <summary>
/// Shared: Determines if the build is going to use cooked data, commandline: -cook, -cookonthefly
/// </summary>
[Help("skipcook", "use a cooked build, but we assume the cooked data is up to date and where it belongs, implies -cook")]
public bool SkipCook { private set; get; }
/// <summary>
/// Shared: In a cookonthefly build, used solely to pass information to the package step. This is necessary because you can't set cookonthefly and cook at the same time, and skipcook sets cook.
/// </summary>
[Help("skipcookonthefly", "in a cookonthefly build, used solely to pass information to the package step")]
public bool SkipCookOnTheFly { private set; get; }
/// <summary>
/// Shared: Determines if the intermediate folders will be wiped before building, commandline: -clean
/// </summary>
[Help("clean", "wipe intermediate folders before building")]
public bool? Clean { private set; get; }
/// <summary>
/// Shared: Assumes no user is sitting at the console, so for example kills clients automatically, commandline: -Unattended
/// </summary>
[Help("unattended", "assumes no operator is present, always terminates without waiting for something.")]
public bool Unattended { private set; get; }
/// <summary>
/// Shared: Sets platforms to build for non-dedicated servers. commandline: -TargetPlatform
/// </summary>
public List<TargetPlatformDescriptor> ClientTargetPlatforms = new List<TargetPlatformDescriptor>();
/// <summary>
/// Shared: Dictionary that maps client dependent platforms to "source" platforms that it should copy data from. commandline: -TargetPlatform=source.dependent
/// </summary>
public Dictionary<TargetPlatformDescriptor, TargetPlatformDescriptor> ClientDependentPlatformMap = new Dictionary<TargetPlatformDescriptor, TargetPlatformDescriptor>();
/// <summary>
/// Shared: Sets platforms to build for dedicated servers. commandline: -ServerTargetPlatform
/// </summary>
public List<TargetPlatformDescriptor> ServerTargetPlatforms = new List<TargetPlatformDescriptor>();
/// <summary>
/// Shared: Dictionary that maps server dependent platforms to "source" platforms that it should copy data from: -ServerTargetPlatform=source.dependent
/// </summary>
public Dictionary<TargetPlatformDescriptor, TargetPlatformDescriptor> ServerDependentPlatformMap = new Dictionary<TargetPlatformDescriptor, TargetPlatformDescriptor>();
/// <summary>
/// Shared: True if pak file should be generated.
/// </summary>
[Help("pak", "generate a pak file")]
public bool Pak { private set; get; }
/// <summary>
///
/// </summary>
public bool UsePak(Platform PlatformToCheck)
{
return Pak || PlatformToCheck.RequiresPak(this) == Platform.PakType.Always;
}
private string SignPakInternal { get; set; }
/// <summary>
/// Shared: Encryption keys used for signing the pak file.
/// </summary>
[Help("signpak=keys", "sign the generated pak file with the specified key, i.e. -signpak=C:\\Encryption.keys. Also implies -signedpak.")]
public string SignPak
{
private set
{
if (string.IsNullOrEmpty(value) || value.StartsWith("0x", StringComparison.InvariantCultureIgnoreCase))
{
SignPakInternal = value;
}
else
{
SignPakInternal = Path.GetFullPath(value);
}
}
get
{
return SignPakInternal;
}
}
/// <summary>
/// Shared: the game will use only signed content.
/// </summary>
[Help("signed", "the game should expect to use a signed pak file.")]
public bool SignedPak { private set; get; }
/// <summary>
/// Shared: true if this build is staged, command line: -stage
/// </summary>
[Help("skippak", "use a pak file, but assume it is already built, implies pak")]
public bool SkipPak { private set; get; }
/// <summary>
/// Shared: true if this build is staged, command line: -stage
/// </summary>
[Help("stage", "put this build in a stage directory")]
public bool Stage { private set; get; }
/// <summary>
/// Shared: true if this build is staged, command line: -stage
/// </summary>
[Help("skipstage", "uses a stage directory, but assumes everything is already there, implies -stage")]
public bool SkipStage { private set; get; }
/// <summary>
/// Shared: true if this build is using streaming install manifests, command line: -manifests
/// </summary>
[Help("manifests", "generate streaming install manifests when cooking data")]
public bool Manifests { private set; get; }
/// <summary>
/// Shared: true if this build chunk install streaming install data, command line: -createchunkinstalldata
/// </summary>
[Help("createchunkinstall", "generate streaming install data from manifest when cooking data, requires -stage & -manifests")]
public bool CreateChunkInstall { private set; get; }
/// <summary>
/// Shared: Directory to use for built chunk install data, command line: -chunkinstalldirectory=
/// </summary>
public string ChunkInstallDirectory { set; get; }
/// <summary>
/// Shared: Version string to use for built chunk install data, command line: -chunkinstallversion=
/// </summary>
public string ChunkInstallVersionString { set; get; }
/// <summary>
/// Shared: Directory to copy the client to, command line: -stagingdirectory=
/// </summary>
public string BaseStageDirectory
{
get
{
if( !String.IsNullOrEmpty(StageDirectoryParam ) )
{
return Path.GetFullPath( StageDirectoryParam );
}
if ( HasDLCName )
{
return Path.GetFullPath( CommandUtils.CombinePaths(Path.GetDirectoryName(RawProjectPath.FullName), "Plugins", DLCName, "Saved", "StagedBuilds" ) );
}
// default return the project saved\stagedbuilds directory
return Path.GetFullPath( CommandUtils.CombinePaths(Path.GetDirectoryName(RawProjectPath.FullName), "Saved", "StagedBuilds") );
}
}
[Help("stagingdirectory=Path", "Directory to copy the builds to, i.e. -stagingdirectory=C:\\Stage")]
public string StageDirectoryParam;
[Help("ue4exe=ExecutableName", "Name of the UE4 Editor executable, i.e. -ue4exe=UE4Editor.exe")]
public string UE4Exe;
/// <summary>
/// Shared: true if this build is archived, command line: -archive
/// </summary>
[Help("archive", "put this build in an archive directory")]
public bool Archive { private set; get; }
/// <summary>
/// Shared: Directory to archive the client to, command line: -archivedirectory=
/// </summary>
public string BaseArchiveDirectory
{
get
{
return Path.GetFullPath(String.IsNullOrEmpty(ArchiveDirectoryParam) ? CommandUtils.CombinePaths(Path.GetDirectoryName(RawProjectPath.FullName), "ArchivedBuilds") : ArchiveDirectoryParam);
}
}
[Help("archivedirectory=Path", "Directory to archive the builds to, i.e. -archivedirectory=C:\\Archive")]
public string ArchiveDirectoryParam;
/// <summary>
/// Whether the project should use non monolithic staging
/// </summary>
[Help("archivemetadata", "Archive extra metadata files in addition to the build (e.g. build.properties)")]
public bool ArchiveMetaData;
/// <summary>
/// When archiving for Mac, set this to true to package it in a .app bundle instead of normal loose files
/// </summary>
[Help("createappbundle", "When archiving for Mac, set this to true to package it in a .app bundle instead of normal loose files")]
public bool CreateAppBundle;
/// <summary>
/// Determines if Blueprint assets should be substituted with auto-generated code.
/// </summary>
[Help("nativizeAssets", "Runs a \"nativization\" pass on Blueprint assets, converting then into C++ (replacing the assets with the generated source).")]
public bool RunAssetNativization;
public struct BlueprintPluginKey
{
public bool Client;
public UnrealTargetPlatform TargetPlatform;
}
/// <summary>
/// Shared: Ref to an auto-generated plugin file that should be incorporated into the project's build
/// </summary>
public Dictionary<BlueprintPluginKey, FileReference> BlueprintPluginPaths = new Dictionary<BlueprintPluginKey, FileReference>();
#endregion
#region Build
/// <summary>
/// Build: True if build step should be executed, command: -build
/// </summary>
[Help("build", "True if build step should be executed")]
public bool Build { private set; get; }
/// <summary>
/// Build: True if XGE should NOT be used for building.
/// </summary>
[Help("noxge", "True if XGE should NOT be used for building")]
public bool NoXGE { private set; get; }
/// <summary>
/// Build: List of maps to cook.
/// </summary>
private ParamList<string> EditorTargetsList = null;
public ParamList<string> EditorTargets
{
set { EditorTargetsList = value; }
get
{
if (EditorTargetsList == null)
{
// Lazy auto-initialization
AutodetectSettings(false);
}
return EditorTargetsList;
}
}
/// <summary>
/// Build: List of maps to cook.
/// </summary>
private ParamList<string> ProgramTargetsList = null;
public ParamList<string> ProgramTargets
{
set { ProgramTargetsList = value; }
get
{
if (ProgramTargetsList == null)
{
// Lazy auto-initialization
AutodetectSettings(false);
}
return ProgramTargetsList;
}
}
/// <summary>
/// Build: List of client configurations
/// </summary>
public List<UnrealTargetConfiguration> ClientConfigsToBuild = new List<UnrealTargetConfiguration>() { UnrealTargetConfiguration.Development };
///<summary>
/// Build: List of Server configurations
/// </summary>
public List<UnrealTargetConfiguration> ServerConfigsToBuild = new List<UnrealTargetConfiguration>() { UnrealTargetConfiguration.Development };
/// <summary>
/// Build: List of client cooked build targets.
/// </summary>
private ParamList<string> ClientCookedTargetsList = null;
public ParamList<string> ClientCookedTargets
{
set { ClientCookedTargetsList = value; }
get
{
if (ClientCookedTargetsList == null)
{
// Lazy auto-initialization
AutodetectSettings(false);
}
return ClientCookedTargetsList;
}
}
/// <summary>
/// Build: List of Server cooked build targets.
/// </summary>
private ParamList<string> ServerCookedTargetsList = null;
public ParamList<string> ServerCookedTargets
{
set { ServerCookedTargetsList = value; }
get
{
if (ServerCookedTargetsList == null)
{
// Lazy auto-initialization
AutodetectSettings(false);
}
return ServerCookedTargetsList;
}
}
#endregion
#region Cook
/// <summary>
/// Cook: List of maps to cook.
/// </summary>
public ParamList<string> MapsToCook = new ParamList<string>();
/// <summary>
/// Cook: List of directories to cook.
/// </summary>
public ParamList<string> DirectoriesToCook = new ParamList<string>();
/// <summary>
/// Cook: Internationalization preset to cook.
/// </summary>
public string InternationalizationPreset;
/// <summary>
/// Cook: Create a cooked release version. Also, the version. e.g. 1.0
/// </summary>
public string CreateReleaseVersion;
/// <summary>
/// Cook: Use new cooker (temporary cooker option until it's enabled permanently)
/// </summary>
public bool NewCook { private set; get; }
/// <summary>
/// Cook: Use old cooker (temporary cooker options until new cook replaces it)
/// </summary>
public bool OldCook { private set; get; }
/// <summary>
/// Cook: Base this cook of a already released version of the cooked data
/// </summary>
public string BasedOnReleaseVersion;
/// <summary>
/// Cook: Path to the root of the directory where we store released versions of the game for a given version
/// </summary>
public string BasedOnReleaseVersionBasePath;
/// <summary>
/// Cook: Path to the root of the directory to create a new released version of the game.
/// </summary>
public string CreateReleaseVersionBasePath;
/// <summary>
/// Are we generating a patch, generate a patch from a previously released version of the game (use CreateReleaseVersion to create a release).
/// this requires BasedOnReleaseVersion
/// see also CreateReleaseVersion, BasedOnReleaseVersion
/// </summary>
public bool GeneratePatch;
/// <summary>
/// Name of dlc to cook and package (if this paramter is supplied cooks the dlc and packages it into the dlc directory)
/// </summary>
public string DLCName;
/// <summary>
/// Enable cooking of engine content when cooking dlc
/// not included in original release but is referenced by current cook
/// </summary>
public bool DLCIncludeEngineContent;
/// <summary>
/// After cook completes diff the cooked content against another cooked content directory.
/// report all errors to the log
/// </summary>
public string DiffCookedContentPath;
/// <summary>
/// Cook: Additional cooker options to include on the cooker commandline
/// </summary>
public string AdditionalCookerOptions;
/// <summary>
/// Cook: List of cultures to cook.
/// </summary>
public ParamList<string> CulturesToCook;
/// <summary>
/// Compress packages during cook.
/// </summary>
public bool Compressed;
/// <summary>
/// Encrypt ini files which are packaged into the pak file. Only valid when encryption keys and building pak file specified.
/// </summary>
public bool EncryptIniFiles;
/// <summary>
/// put -debug on the editorexe commandline
/// </summary>
public bool UseDebugParamForEditorExe;
/// <summary>
/// Cook: Do not include a version number in the cooked content
/// </summary>
public bool UnversionedCookedContent = true;
/// <summary>
/// Cook: Uses the iterative cooking, command line: -iterativecooking or -iterate
/// </summary>
[Help( "iterativecooking", "Uses the iterative cooking, command line: -iterativecooking or -iterate" )]
public bool IterativeCooking;
/// <summary>
/// Cook: Only cook maps (and referenced content) instead of cooking everything only affects -cookall flag
/// </summary>
[Help("CookMapsOnly", "Cook only maps this only affects usage of -cookall the flag")]
public bool CookMapsOnly;
/// <summary>
/// Cook: Only cook maps (and referenced content) instead of cooking everything only affects cookall flag
/// </summary>
[Help("CookAll", "Cook all the things in the content directory for this project")]
public bool CookAll;
/// <summary>
/// Cook: Skip cooking editor content
/// </summary>
[Help("SkipCookingEditorContent", "Skips content under /Engine/Editor when cooking")]
public bool SkipCookingEditorContent;
/// <summary>
/// Cook: number of additional cookers to spawn while cooking
/// </summary>
public int NumCookersToSpawn;
/// <summary>
/// Cook: Uses the iterative deploy, command line: -iterativedeploy or -iterate
/// </summary>
[Help("iterativecooking", "Uses the iterative cooking, command line: -iterativedeploy or -iterate")]
public bool IterativeDeploy;
[Help("FastCook", "Uses fast cook path if supported by target")]
public bool FastCook;
/// <summary>
/// Cook: Ignores cook errors and continues with packaging etc.
/// </summary>
[Help("IgnoreCookErrors", "Ignores cook errors and continues with packaging etc")]
public bool IgnoreCookErrors { private set; get; }
#endregion
#region Stage
/// <summary>
/// Stage: Commanndline: -nodebuginfo
/// </summary>
[Help("nodebuginfo", "do not copy debug files to the stage")]
public bool NoDebugInfo { private set; get; }
/// <summary>
/// true if the staging directory is to be cleaned: -cleanstage (also true if -clean is specified)
/// </summary>
[Help("nocleanstage", "skip cleaning the stage directory")]
public bool NoCleanStage { set { bNoCleanStage = value; } get { return SkipStage || bNoCleanStage; } }
private bool bNoCleanStage;
/// <summary>
/// Stage: If non-empty, the contents will be put into the stage
/// </summary>
[Help("cmdline", "command line to put into the stage in UE4CommandLine.txt")]
public string StageCommandline;
/// <summary>
/// Stage: If non-empty, the contents will be used for the bundle name
/// </summary>
[Help("bundlename", "string to use as the bundle name when deploying to mobile device")]
public string BundleName;
/// <summary>
/// Whether the project uses Steam (todo: substitute with more generic functionality)
/// </summary>
public bool bUsesSteam;
/// <summary>
/// Whether the project uses CEF3
/// </summary>
public bool bUsesCEF3;
/// <summary>
/// Whether the project uses visual Slate UI (as opposed to the low level windowing/messaging which is alway used)
/// </summary>
public bool bUsesSlate = true;
/// <summary>
/// Hack for legacy game styling isses. No new project should ever set this to true
/// Whether the project uses the Slate editor style in game.
/// </summary>
public bool bUsesSlateEditorStyle = false;
/// <summary>
/// By default we use the Release C++ Runtime (CRT), even when compiling Debug builds. This is because the Debug C++
/// Runtime isn't very useful when debugging Unreal Engine projects, and linking against the Debug CRT libraries forces
/// our third party library dependencies to also be compiled using the Debug CRT (and often perform more slowly.) Often
/// it can be inconvenient to require a separate copy of the debug versions of third party static libraries simply
/// so that you can debug your program's code.
/// </summary>
public bool bDebugBuildsActuallyUseDebugCRT = false;
/// <summary>
/// On Windows, adds an executable to the root of the staging directory which checks for prerequisites being
/// installed and launches the game with a path to the .uproject file.
/// </summary>
public bool NoBootstrapExe { get; set; }
/// <summary>
/// By default we don't code sign unless it is required or requested
/// </summary>
public bool bCodeSign = false;
/// <summary>
/// Provision to use
/// </summary>
public string Provision = null;
/// <summary>
/// Certificate to use
/// </summary>
public string Certificate = null;
/// <summary>
/// TitleID to package
/// </summary>
public ParamList<string> TitleID = new ParamList<string>();
/// <summary>
/// If true, non-shipping binaries will be considered DebugUFS files and will appear on the debugfiles manifest
/// </summary>
public bool bTreatNonShippingBinariesAsDebugFiles = false;
#endregion
#region Run
/// <summary>
/// Run: True if the Run step should be executed, command: -run
/// </summary>
[Help("run", "run the game after it is built (including server, if -server)")]
public bool Run { private set; get; }
/// <summary>
/// Run: The client runs with cooked data provided by cook on the fly server, command line: -cookonthefly
/// </summary>
[Help("cookonthefly", "run the client with cooked data provided by cook on the fly server")]
public bool CookOnTheFly { private set; get; }
/// <summary>
/// Run: The client should run in streaming mode when connecting to cook on the fly server
/// </summary>
[Help("Cookontheflystreaming", "run the client in streaming cook on the fly mode (don't cache files locally instead force reget from server each file load)")]
public bool CookOnTheFlyStreaming { private set; get; }
/// <summary>
/// Run: The client should run in streaming mode when connecting to cook on the fly server
/// </summary>
[Help("CookPartialgc", "while cooking clean up packages as we are done with them rather then cleaning everything up when we run out of space")]
public bool CookPartialGC { private set; get; }
/// <summary>
/// Run: The client runs with cooked data provided by UnrealFileServer, command line: -fileserver
/// </summary>
[Help("fileserver", "run the client with cooked data provided by UnrealFileServer")]
public bool FileServer { private set; get; }
/// <summary>
/// Run: The client connects to dedicated server to get data, command line: -dedicatedserver
/// </summary>
[Help("dedicatedserver", "build, cook and run both a client and a server (also -server)")]
public bool DedicatedServer { private set; get; }
/// <summary>
/// Run: Uses a client target configuration, also implies -dedicatedserver, command line: -client
/// </summary>
[Help( "client", "build, cook and run a client and a server, uses client target configuration" )]
public bool Client { private set; get; }
/// <summary>
/// Run: Whether the client should start or not, command line (to disable): -noclient
/// </summary>
[Help("noclient", "do not run the client, just run the server")]
public bool NoClient { private set; get; }
/// <summary>
/// Run: Client should create its own log window, command line: -logwindow
/// </summary>
[Help("logwindow", "create a log window for the client")]
public bool LogWindow { private set; get; }
/// <summary>
/// Run: Map to run the game with.
/// </summary>
[Help("map", "map to run the game with")]
public string MapToRun;
/// <summary>
/// Run: Additional server map params.
/// </summary>
[Help("AdditionalServerMapParams", "Additional server map params, i.e ?param=value")]
public string AdditionalServerMapParams;
/// <summary>
/// Run: The target device to run the game on. Comes in the form platform@devicename.
/// </summary>
[Help("device", "Devices to run the game on")]
public ParamList<string> Devices;
/// <summary>
/// Run: The target device to run the game on. No platform prefix.
/// </summary>
[Help("device", "Device names without the platform prefix to run the game on")]
public ParamList<string> DeviceNames;
/// <summary>
/// Run: the target device to run the server on
/// </summary>
[Help("serverdevice", "Device to run the server on")]
public string ServerDevice;
/// <summary>
/// Run: The indicated server has already been started
/// </summary>
[Help("skipserver", "Skip starting the server")]
public bool SkipServer;
/// <summary>
/// Run: The indicated server has already been started
/// </summary>
[Help("numclients=n", "Start extra clients, n should be 2 or more")]
public int NumClients;
/// <summary>
/// Run: Additional command line arguments to pass to the program
/// </summary>
[Help("addcmdline", "Additional command line arguments for the program")]
public string RunCommandline;
/// <summary>
/// Run: Additional command line arguments to pass to the server
/// </summary>
[Help("servercmdline", "Additional command line arguments for the program")]
public string ServerCommandline;
/// <summary>
/// Run:adds -nullrhi to the client commandline
/// </summary>
[Help("nullrhi", "add -nullrhi to the client commandlines")]
public bool NullRHI;
/// <summary>
/// Run:adds ?fake to the server URL
/// </summary>
[Help("fakeclient", "adds ?fake to the server URL")]
public bool FakeClient;
/// <summary>
/// Run:adds ?fake to the server URL
/// </summary>
[Help("editortest", "rather than running a client, run the editor instead")]
public bool EditorTest;
/// <summary>
/// Run:when running -editortest or a client, run all automation tests, not compatible with -server
/// </summary>
[Help("RunAutomationTests", "when running -editortest or a client, run all automation tests, not compatible with -server")]
public bool RunAutomationTests;
/// <summary>
/// Run:when running -editortest or a client, run all automation tests, not compatible with -server
/// </summary>
[Help("RunAutomationTests", "when running -editortest or a client, run a specific automation tests, not compatible with -server")]
public string RunAutomationTest;
/// <summary>
/// Run: Adds commands like debug crash, debug rendercrash, etc based on index
/// </summary>
[Help("Crash=index", "when running -editortest or a client, adds commands like debug crash, debug rendercrash, etc based on index")]
public int CrashIndex;
public ParamList<string> Port;
/// <summary>
/// Run: Linux username for unattended key genereation
/// </summary>
[Help("deviceuser", "Linux username for unattended key genereation")]
public string DeviceUsername;
/// <summary>
/// Run: Linux password for unattended key genereation
/// </summary>
[Help("devicepass", "Linux password for unattended key genereation")]
public string DevicePassword;
/// <summary>
/// Run: Sever device IP address
/// </summary>
public string ServerDeviceAddress;
#endregion
#region Package
[Help("package", "package the project for the target platform")]
public bool Package { get; set; }
[Help("distribution", "package for distribution the project")]
public bool Distribution { get; set; }
[Help("prereqs", "stage prerequisites along with the project")]
public bool Prereqs { get; set; }
[Help("applocaldir", "location of prerequisites for applocal deployment")]
public string AppLocalDirectory { get; set; }
[Help("Prebuilt", "this is a prebuilt cooked and packaged build")]
public bool Prebuilt { get; private set; }
[Help("RunTimeoutSeconds", "timeout to wait after we lunch the game")]
public int RunTimeoutSeconds;
[Help("SpecifiedArchitecture", "Determine a specific Minimum OS")]
public string SpecifiedArchitecture;
#endregion
#region Deploy
[Help("deploy", "deploy the project for the target platform")]
public bool Deploy { get; set; }
#endregion
#region Misc
[Help("MapsToRebuildLightMaps", "List of maps that need light maps rebuilding")]
public ParamList<string> MapsToRebuildLightMaps = new ParamList<string>();
[Help("IgnoreLightMapErrors", "Whether Light Map errors should be treated as critical")]
public bool IgnoreLightMapErrors { get; set; }
#endregion
#region Initialization
private Dictionary<TargetRules.TargetType, SingleTargetProperties> DetectedTargets;
private Dictionary<UnrealTargetPlatform, ConfigCacheIni> LoadedEngineConfigs;
private Dictionary<UnrealTargetPlatform, ConfigCacheIni> LoadedGameConfigs;
private void AutodetectSettings(bool bReset)
{
if (bReset)
{
EditorTargetsList = null;
ClientCookedTargetsList = null;
ServerCookedTargetsList = null;
ProgramTargetsList = null;
ProjectBinariesPath = null;
ProjectGameExePath = null;
}
List<UnrealTargetPlatform> ClientTargetPlatformTypes = ClientTargetPlatforms.ConvertAll(x => x.Type).Distinct().ToList();
var Properties = ProjectUtils.GetProjectProperties(RawProjectPath, ClientTargetPlatformTypes, RunAssetNativization);
bUsesSteam = Properties.bUsesSteam;
bUsesCEF3 = Properties.bUsesCEF3;
bUsesSlate = Properties.bUsesSlate;
bUsesSlateEditorStyle = Properties.bUsesSlateEditorStyle;
bDebugBuildsActuallyUseDebugCRT = Properties.bDebugBuildsActuallyUseDebugCRT;
bIsCodeBasedProject = Properties.bIsCodeBasedProject;
DetectedTargets = Properties.Targets;
LoadedEngineConfigs = Properties.EngineConfigs;
LoadedGameConfigs = Properties.GameConfigs;
var GameTarget = String.Empty;
var EditorTarget = String.Empty;
var ServerTarget = String.Empty;
var ProgramTarget = String.Empty;
var ProjectType = TargetRules.TargetType.Game;
if (!bIsCodeBasedProject)
{
GameTarget = "UE4Game";
EditorTarget = "UE4Editor";
ServerTarget = "UE4Server";
}
else if (!CommandUtils.CmdEnv.HasCapabilityToCompile)
{
var ShortName = ProjectUtils.GetShortProjectName(RawProjectPath);
GameTarget = ShortName;
EditorTarget = ShortName + "Editor";
ServerTarget = ShortName + "Server";
}
else if (!CommandUtils.IsNullOrEmpty(Properties.Targets))
{
SingleTargetProperties TargetData;
var GameTargetType = TargetRules.TargetType.Game;
if( Client )
{
if( HasClientTargetDetected )
{
GameTargetType = TargetRules.TargetType.Client;
}
else
{
throw new AutomationException( "Client target not found!" );
}
}
var ValidGameTargetTypes = new TargetRules.TargetType[]
{
GameTargetType,
TargetRules.TargetType.Program
};
foreach (var ValidTarget in ValidGameTargetTypes)
{
if (DetectedTargets.TryGetValue(ValidTarget, out TargetData))
{
GameTarget = TargetData.TargetName;
bDebugBuildsActuallyUseDebugCRT = TargetData.Rules.bDebugBuildsActuallyUseDebugCRT;
bUsesSlate = TargetData.Rules.bUsesSlate;
bUsesSlateEditorStyle = TargetData.Rules.bUsesSlateEditorStyle;
bUsesSteam = TargetData.Rules.bUsesSteam;
bUsesCEF3 = TargetData.Rules.bUsesCEF3;
ProjectType = ValidTarget;
break;
}
}
if (DetectedTargets.TryGetValue(TargetRules.TargetType.Editor, out TargetData))
{
EditorTarget = TargetData.TargetName;
}
if (DetectedTargets.TryGetValue(TargetRules.TargetType.Server, out TargetData))
{
ServerTarget = TargetData.TargetName;
}
if (DetectedTargets.TryGetValue(TargetRules.TargetType.Program, out TargetData))
{
ProgramTarget = TargetData.TargetName;
}
}
else if (!CommandUtils.IsNullOrEmpty(Properties.Programs))
{
SingleTargetProperties TargetData = Properties.Programs[0];
bDebugBuildsActuallyUseDebugCRT = TargetData.Rules.bDebugBuildsActuallyUseDebugCRT;
bUsesSlate = TargetData.Rules.bUsesSlate;
bUsesSlateEditorStyle = TargetData.Rules.bUsesSlateEditorStyle;
bUsesSteam = TargetData.Rules.bUsesSteam;
bUsesCEF3 = TargetData.Rules.bUsesCEF3;
ProjectType = TargetRules.TargetType.Program;
ProgramTarget = TargetData.TargetName;
GameTarget = TargetData.TargetName;
}
else if (!this.Build)
{
var ShortName = ProjectUtils.GetShortProjectName(RawProjectPath);
GameTarget = ShortName;
EditorTarget = ShortName + "Editor";
ServerTarget = ShortName + "Server";
}
else
{
throw new AutomationException("{0} does not look like uproject file but no targets have been found!", RawProjectPath);
}
IsProgramTarget = ProjectType == TargetRules.TargetType.Program;
if (String.IsNullOrEmpty(EditorTarget) && ProjectType != TargetRules.TargetType.Program && CommandUtils.IsNullOrEmpty(EditorTargetsList))
{
if (Properties.bWasGenerated)
{
EditorTarget = "UE4Editor";
}
else
{
throw new AutomationException("Editor target not found!");
}
}
if (String.IsNullOrEmpty(GameTarget) && Run && !NoClient && (Cook || CookOnTheFly) && CommandUtils.IsNullOrEmpty(ClientCookedTargetsList))
{
throw new AutomationException("Game target not found. Game target is required with -cook or -cookonthefly");
}
if (EditorTargetsList == null)
{
if (!GlobalCommandLine.NoCompileEditor && (ProjectType != TargetRules.TargetType.Program) && !String.IsNullOrEmpty(EditorTarget))
{
EditorTargetsList = new ParamList<string>(EditorTarget);
}
else
{
EditorTargetsList = new ParamList<string>();
}
}
if (ProgramTargetsList == null)
{
if (ProjectType == TargetRules.TargetType.Program)
{
ProgramTargetsList = new ParamList<string>(ProgramTarget);
}
else
{
ProgramTargetsList = new ParamList<string>();
}
}
if (ClientCookedTargetsList == null && !NoClient && (Cook || CookOnTheFly || Prebuilt))
{
if (String.IsNullOrEmpty(GameTarget))
{
throw new AutomationException("Game target not found. Game target is required with -cook or -cookonthefly");
}
else
{
ClientCookedTargetsList = new ParamList<string>(GameTarget);
}
}
else if (ClientCookedTargetsList == null)
{
ClientCookedTargetsList = new ParamList<string>();
}
if (ServerCookedTargetsList == null && DedicatedServer && (Cook || CookOnTheFly))
{
if (String.IsNullOrEmpty(ServerTarget))
{
throw new AutomationException("Server target not found. Server target is required with -server and -cook or -cookonthefly");
}
ServerCookedTargetsList = new ParamList<string>(ServerTarget);
}
else if (ServerCookedTargetsList == null)
{
ServerCookedTargetsList = new ParamList<string>();
}
if (String.IsNullOrEmpty(ProjectBinariesPath) || String.IsNullOrEmpty(ProjectGameExePath))
{
if ( ClientTargetPlatforms.Count > 0 )
{
var ProjectClientBinariesPath = ProjectUtils.GetClientProjectBinariesRootPath(RawProjectPath, ProjectType, Properties.bIsCodeBasedProject);
ProjectBinariesPath = ProjectUtils.GetProjectClientBinariesFolder(ProjectClientBinariesPath, ClientTargetPlatforms[0].Type);
ProjectGameExePath = CommandUtils.CombinePaths(ProjectBinariesPath, GameTarget + Platform.GetExeExtension(ClientTargetPlatforms[0].Type));
}
}
}
#endregion
#region Utilities
public bool HasEditorTargets
{
get { return !CommandUtils.IsNullOrEmpty(EditorTargets); }
}
public bool HasCookedTargets
{
get { return !CommandUtils.IsNullOrEmpty(ClientCookedTargets) || !CommandUtils.IsNullOrEmpty(ServerCookedTargets); }
}
public bool HasServerCookedTargets
{
get { return !CommandUtils.IsNullOrEmpty(ServerCookedTargets); }
}
public bool HasClientCookedTargets
{
get { return !CommandUtils.IsNullOrEmpty(ClientCookedTargets); }
}
public bool HasProgramTargets
{
get { return !CommandUtils.IsNullOrEmpty(ProgramTargets); }
}
public bool HasMapsToCook
{
get { return !CommandUtils.IsNullOrEmpty(MapsToCook); }
}
public bool HasDirectoriesToCook
{
get { return !CommandUtils.IsNullOrEmpty(DirectoriesToCook); }
}
public bool HasInternationalizationPreset
{
get { return !String.IsNullOrEmpty(InternationalizationPreset); }
}
public bool HasBasedOnReleaseVersion
{
get { return !String.IsNullOrEmpty(BasedOnReleaseVersion); }
}
public bool HasAdditionalCookerOptions
{
get { return !String.IsNullOrEmpty(AdditionalCookerOptions); }
}
public bool HasDLCName
{
get { return !String.IsNullOrEmpty(DLCName); }
}
public bool HasDiffCookedContentPath
{
get { return !String.IsNullOrEmpty(DiffCookedContentPath); }
}
public bool HasCreateReleaseVersion
{
get { return !String.IsNullOrEmpty(CreateReleaseVersion); }
}
public bool HasCulturesToCook
{
get { return CulturesToCook != null; }
}
public bool HasGameTargetDetected
{
get { return ProjectTargets.ContainsKey(TargetRules.TargetType.Game); }
}
public bool HasClientTargetDetected
{
get { return ProjectTargets.ContainsKey( TargetRules.TargetType.Client ); }
}
public bool HasDedicatedServerAndClient
{
get { return Client && DedicatedServer; }
}
/// <summary>
/// Project name (name of the uproject file without extension or directory name where the project is localed)
/// </summary>
public string ShortProjectName
{
get { return ProjectUtils.GetShortProjectName(RawProjectPath); }
}
/// <summary>
/// True if this project contains source code.
/// </summary>
public bool IsCodeBasedProject
{
get
{
return bIsCodeBasedProject;
}
}
private bool bIsCodeBasedProject;
public FileReference CodeBasedUprojectPath
{
get { return IsCodeBasedProject ? RawProjectPath : null; }
}
/// <summary>
/// True if this project is a program.
/// </summary>
public bool IsProgramTarget { get; private set; }
/// <summary>
/// Path where the project's game (or program) binaries are built.
/// </summary>
public string ProjectBinariesFolder
{
get
{
if (String.IsNullOrEmpty(ProjectBinariesPath))
{
AutodetectSettings(false);
}
return ProjectBinariesPath;
}
}
private string ProjectBinariesPath;
/// <summary>
/// Get the path to the directory of the version we are basing a diff or a patch on.
/// </summary>
public String GetBasedOnReleaseVersionPath(DeploymentContext SC, bool bIsClientOnly)
{
String BasePath = BasedOnReleaseVersionBasePath;
String Platform = SC.StageTargetPlatform.GetCookPlatform(SC.DedicatedServer, bIsClientOnly);
if (String.IsNullOrEmpty(BasePath))
{
BasePath = CommandUtils.CombinePaths(SC.ProjectRoot, "Releases", BasedOnReleaseVersion, Platform);
}
else
{
BasePath = CommandUtils.CombinePaths(BasePath, BasedOnReleaseVersion, Platform);
}
/*if ( TitleID != null && TitleID.Count == 1 )
{
BasePath = CommandUtils.CombinePaths( BasePath, TitleID[0]);
}*/
return BasePath;
}
/// <summary>
/// Get the path to the target directory for creating a new release version
/// </summary>
/// <param name="SC"></param>
/// <returns></returns>
public String GetCreateReleaseVersionPath(DeploymentContext SC, bool bIsClientOnly)
{
String BasePath = CreateReleaseVersionBasePath;
String Platform = SC.StageTargetPlatform.GetCookPlatform(SC.DedicatedServer, bIsClientOnly);
if (String.IsNullOrEmpty(BasePath))
{
BasePath = CommandUtils.CombinePaths(SC.ProjectRoot, "Releases", CreateReleaseVersion, Platform);
}
else
{
BasePath = CommandUtils.CombinePaths(BasePath, CreateReleaseVersion, Platform);
}
/*if (TitleID != null && TitleID.Count == 1)
{
BasePath = CommandUtils.CombinePaths(BasePath, TitleID[0]);
}*/
return BasePath;
}
/// <summary>
/// True if we are generating a patch
/// </summary>
public bool IsGeneratingPatch
{
get { return GeneratePatch; }
}
/// <summary>
/// Filename of the target game exe (or program exe).
/// </summary>
public string ProjectGameExeFilename
{
get
{
if (String.IsNullOrEmpty(ProjectGameExePath))
{
AutodetectSettings(false);
}
return ProjectGameExePath;
}
}
private string ProjectGameExePath;
public List<Platform> ClientTargetPlatformInstances
{
get
{
List<Platform> ClientPlatformInstances = new List<Platform>();
foreach ( var ClientPlatform in ClientTargetPlatforms )
{
ClientPlatformInstances.Add(Platform.Platforms[ClientPlatform]);
}
return ClientPlatformInstances;
}
}
public TargetPlatformDescriptor GetCookedDataPlatformForClientTarget(TargetPlatformDescriptor TargetPlatformDesc)
{
if (ClientDependentPlatformMap.ContainsKey(TargetPlatformDesc))
{
return ClientDependentPlatformMap[TargetPlatformDesc];
}
return TargetPlatformDesc;
}
public List<Platform> ServerTargetPlatformInstances
{
get
{
List<Platform> ServerPlatformInstances = new List<Platform>();
foreach (var ServerPlatform in ServerTargetPlatforms)
{
ServerPlatformInstances.Add(Platform.Platforms[ServerPlatform]);
}
return ServerPlatformInstances;
}
}
public TargetPlatformDescriptor GetCookedDataPlatformForServerTarget(TargetPlatformDescriptor TargetPlatformType)
{
if (ServerDependentPlatformMap.ContainsKey(TargetPlatformType))
{
return ServerDependentPlatformMap[TargetPlatformType];
}
return TargetPlatformType;
}
/// <summary>
/// All auto-detected targets for this project
/// </summary>
public Dictionary<TargetRules.TargetType, SingleTargetProperties> ProjectTargets
{
get
{
if (DetectedTargets == null)
{
AutodetectSettings(false);
}
return DetectedTargets;
}
}
/// <summary>
/// List of all Engine ini files for this project
/// </summary>
public Dictionary<UnrealTargetPlatform, ConfigCacheIni> EngineConfigs
{
get
{
if (LoadedEngineConfigs == null)
{
AutodetectSettings(false);
}
return LoadedEngineConfigs;
}
}
/// <summary>
/// List of all Game ini files for this project
/// </summary>
public Dictionary<UnrealTargetPlatform, ConfigCacheIni> GameConfigs
{
get
{
if (LoadedGameConfigs == null)
{
AutodetectSettings(false);
}
return LoadedGameConfigs;
}
}
public void Validate()
{
if (RawProjectPath == null)
{
throw new AutomationException("RawProjectPath can't be empty.");
}
if (!RawProjectPath.HasExtension(".uproject"))
{
throw new AutomationException("RawProjectPath {0} must end with .uproject", RawProjectPath);
}
if (!CommandUtils.FileExists_NoExceptions(RawProjectPath.FullName))
{
throw new AutomationException("RawProjectPath {0} file must exist", RawProjectPath);
}
if (FileServer && !Cook)
{
throw new AutomationException("Only cooked builds can use a fileserver be staged, use -cook");
}
if (Stage && !Cook && !CookOnTheFly && !IsProgramTarget)
{
throw new AutomationException("Only cooked builds or programs can be staged, use -cook or -cookonthefly.");
}
if (Manifests && !Cook && !Stage && !Pak)
{
throw new AutomationException("Only staged pakd and cooked builds can generate streaming install manifests");
}
if (Pak && !Stage)
{
throw new AutomationException("Only staged builds can be paked, use -stage or -skipstage.");
}
if (Deploy && !Stage)
{
throw new AutomationException("Only staged builds can be deployed, use -stage or -skipstage.");
}
if ((Pak || Stage || Cook || CookOnTheFly || FileServer || DedicatedServer) && EditorTest)
{
throw new AutomationException("None of pak, stage, cook, CookOnTheFly or DedicatedServer can be used with EditorTest");
}
if (DedicatedServer && RunAutomationTests)
{
throw new AutomationException("DedicatedServer cannot be used with RunAutomationTests");
}
if ((CookOnTheFly || FileServer) && DedicatedServer)
{
throw new AutomationException("Don't use either -cookonthefly or -fileserver with -server.");
}
if (NoClient && !DedicatedServer && !CookOnTheFly)
{
throw new AutomationException("-noclient can only be used with -server or -cookonthefly.");
}
if (Build && !HasCookedTargets && !HasEditorTargets && !HasProgramTargets)
{
throw new AutomationException("-build is specified but there are no targets to build.");
}
if (Pak && FileServer)
{
throw new AutomationException("Can't use -pak and -fileserver at the same time.");
}
if (Cook && CookOnTheFly)
{
throw new AutomationException("Can't use both -cook and -cookonthefly.");
}
if (!HasDLCName && DLCIncludeEngineContent)
{
throw new AutomationException("DLCIncludeEngineContent flag is only valid when cooking dlc.");
}
if ((IsGeneratingPatch || HasDLCName) && !HasBasedOnReleaseVersion)
{
throw new AutomationException("Require based on release version to build patches or dlc");
}
if (HasCreateReleaseVersion && (IsGeneratingPatch || HasDLCName))
{
throw new AutomationException("Can't create a release version at the same time as creating dlc.");
}
if (HasBasedOnReleaseVersion && (IterativeCooking || IterativeDeploy))
{
throw new AutomationException("Can't use iterative cooking / deploy on dlc or patching or creating a release");
}
/*if (Compressed && !Pak)
{
throw new AutomationException("-compressed can only be used with -pak");
}*/
if (CreateChunkInstall && (!(Manifests || HasDLCName) || !Stage))
{
throw new AutomationException("-createchunkinstall can only be used with -manifests & -stage");
}
if (CreateChunkInstall && String.IsNullOrEmpty(ChunkInstallDirectory))
{
throw new AutomationException("-createchunkinstall must specify the chunk install data directory with -chunkinstalldirectory=");
}
if (CreateChunkInstall && String.IsNullOrEmpty(ChunkInstallVersionString))
{
throw new AutomationException("-createchunkinstall must specify the chunk install data version string with -chunkinstallversion=");
}
}
protected bool bLogged = false;
public virtual void ValidateAndLog()
{
// Avoid spamming, log only once
if (!bLogged)
{
// In alphabetical order.
CommandUtils.LogLog("Project Params **************");
CommandUtils.LogLog("AdditionalServerMapParams={0}", AdditionalServerMapParams);
CommandUtils.LogLog("Archive={0}", Archive);
CommandUtils.LogLog("ArchiveMetaData={0}", ArchiveMetaData);
CommandUtils.LogLog("CreateAppBundle={0}", CreateAppBundle);
CommandUtils.LogLog("BaseArchiveDirectory={0}", BaseArchiveDirectory);
CommandUtils.LogLog("BaseStageDirectory={0}", BaseStageDirectory);
CommandUtils.LogLog("Build={0}", Build);
CommandUtils.LogLog("Cook={0}", Cook);
CommandUtils.LogLog("Clean={0}", Clean);
CommandUtils.LogLog("Client={0}", Client);
CommandUtils.LogLog("ClientConfigsToBuild={0}", string.Join(",", ClientConfigsToBuild));
CommandUtils.LogLog("ClientCookedTargets={0}", ClientCookedTargets.ToString());
CommandUtils.LogLog("ClientTargetPlatform={0}", string.Join(",", ClientTargetPlatforms));
CommandUtils.LogLog("Compressed={0}", Compressed);
CommandUtils.LogLog("UseDebugParamForEditorExe={0}", UseDebugParamForEditorExe);
CommandUtils.LogLog("CookOnTheFly={0}", CookOnTheFly);
CommandUtils.LogLog("CookOnTheFlyStreaming={0}", CookOnTheFlyStreaming);
CommandUtils.LogLog("UnversionedCookedContent={0}", UnversionedCookedContent);
CommandUtils.LogLog("EncryptIniFiles={0}", EncryptIniFiles);
CommandUtils.LogLog("SkipCookingEditorContent={0}", SkipCookingEditorContent);
CommandUtils.LogLog("NumCookersToSpawn={0}", NumCookersToSpawn);
CommandUtils.LogLog("GeneratePatch={0}", GeneratePatch);
CommandUtils.LogLog("CreateReleaseVersion={0}", CreateReleaseVersion);
CommandUtils.LogLog("BasedOnReleaseVersion={0}", BasedOnReleaseVersion);
CommandUtils.LogLog("DLCName={0}", DLCName);
CommandUtils.LogLog("DLCIncludeEngineContent={0}", DLCIncludeEngineContent);
CommandUtils.LogLog("DiffCookedContentPath={0}", DiffCookedContentPath);
CommandUtils.LogLog("AdditionalCookerOptions={0}", AdditionalCookerOptions);
CommandUtils.LogLog("DedicatedServer={0}", DedicatedServer);
CommandUtils.LogLog("DirectoriesToCook={0}", DirectoriesToCook.ToString());
CommandUtils.LogLog("CulturesToCook={0}", CommandUtils.IsNullOrEmpty(CulturesToCook) ? "<Not Specified> (Use Defaults)" : CulturesToCook.ToString());
CommandUtils.LogLog("EditorTargets={0}", EditorTargets.ToString());
CommandUtils.LogLog("Foreign={0}", Foreign);
CommandUtils.LogLog("IsCodeBasedProject={0}", IsCodeBasedProject.ToString());
CommandUtils.LogLog("IsProgramTarget={0}", IsProgramTarget.ToString());
CommandUtils.LogLog("IterativeCooking={0}", IterativeCooking);
CommandUtils.LogLog("CookAll={0}", CookAll);
CommandUtils.LogLog("CookPartialGC={0}", CookPartialGC);
CommandUtils.LogLog("CookMapsOnly={0}", CookMapsOnly);
CommandUtils.LogLog("Deploy={0}", Deploy);
CommandUtils.LogLog("IterativeDeploy={0}", IterativeDeploy);
CommandUtils.LogLog("FastCook={0}", FastCook);
CommandUtils.LogLog("LogWindow={0}", LogWindow);
CommandUtils.LogLog("Manifests={0}", Manifests);
CommandUtils.LogLog("MapToRun={0}", MapToRun);
CommandUtils.LogLog("NoClient={0}", NoClient);
CommandUtils.LogLog("NumClients={0}", NumClients);
CommandUtils.LogLog("NoDebugInfo={0}", NoDebugInfo);
CommandUtils.LogLog("NoCleanStage={0}", NoCleanStage);
CommandUtils.LogLog("NoXGE={0}", NoXGE);
CommandUtils.LogLog("MapsToCook={0}", MapsToCook.ToString());
CommandUtils.LogLog("Pak={0}", Pak);
CommandUtils.LogLog("Package={0}", Package);
CommandUtils.LogLog("NullRHI={0}", NullRHI);
CommandUtils.LogLog("FakeClient={0}", FakeClient);
CommandUtils.LogLog("EditorTest={0}", EditorTest);
CommandUtils.LogLog("RunAutomationTests={0}", RunAutomationTests);
CommandUtils.LogLog("RunAutomationTest={0}", RunAutomationTest);
CommandUtils.LogLog("RunTimeoutSeconds={0}", RunTimeoutSeconds);
CommandUtils.LogLog("CrashIndex={0}", CrashIndex);
CommandUtils.LogLog("ProgramTargets={0}", ProgramTargets.ToString());
CommandUtils.LogLog("ProjectBinariesFolder={0}", ProjectBinariesFolder);
CommandUtils.LogLog("ProjectBinariesPath={0}", ProjectBinariesPath);
CommandUtils.LogLog("ProjectGameExeFilename={0}", ProjectGameExeFilename);
CommandUtils.LogLog("ProjectGameExePath={0}", ProjectGameExePath);
CommandUtils.LogLog("Distribution={0}", Distribution);
CommandUtils.LogLog("Prebuilt={0}", Prebuilt);
CommandUtils.LogLog("Prereqs={0}", Prereqs);
CommandUtils.LogLog("AppLocalDirectory={0}", AppLocalDirectory);
CommandUtils.LogLog("NoBootstrapExe={0}", NoBootstrapExe);
CommandUtils.LogLog("RawProjectPath={0}", RawProjectPath);
CommandUtils.LogLog("Run={0}", Run);
CommandUtils.LogLog("ServerConfigsToBuild={0}", string.Join(",", ServerConfigsToBuild));
CommandUtils.LogLog("ServerCookedTargets={0}", ServerCookedTargets.ToString());
CommandUtils.LogLog("ServerTargetPlatform={0}", string.Join(",", ServerTargetPlatforms));
CommandUtils.LogLog("ShortProjectName={0}", ShortProjectName.ToString());
CommandUtils.LogLog("SignedPak={0}", SignedPak);
CommandUtils.LogLog("SignPak={0}", SignPak);
CommandUtils.LogLog("SkipCook={0}", SkipCook);
CommandUtils.LogLog("SkipCookOnTheFly={0}", SkipCookOnTheFly);
CommandUtils.LogLog("SkipPak={0}", SkipPak);
CommandUtils.LogLog("SkipStage={0}", SkipStage);
CommandUtils.LogLog("Stage={0}", Stage);
CommandUtils.LogLog("bUsesSteam={0}", bUsesSteam);
CommandUtils.LogLog("bUsesCEF3={0}", bUsesCEF3);
CommandUtils.LogLog("bUsesSlate={0}", bUsesSlate);
CommandUtils.LogLog("bDebugBuildsActuallyUseDebugCRT={0}", bDebugBuildsActuallyUseDebugCRT);
CommandUtils.LogLog("bTreatNonShippingBinariesAsDebugFiles={0}", bTreatNonShippingBinariesAsDebugFiles);
CommandUtils.LogLog("NativizeAssets={0}", RunAssetNativization);
CommandUtils.LogLog("Project Params **************");
}
bLogged = true;
Validate();
}
#endregion
}
}
Reference in New Issue View Git Blame Copy Permalink