file
class        class UProjectPackagingSettings : public UObject

	 */
	UPROPERTY(config, EditAnywhere, Category=Packaging)
	bool bGenerateChunks;

	/** 
	 * If enabled, no platform will generate chunks, regardless of settings in platform-specific ini files.
	 */
	UPROPERTY(config, EditAnywhere, Category=Packaging)
	bool bGenerateNoChunks;

file
function     void UProjectPackagingSettings::PostEditChangeProperty

	else if (Name == FName(TEXT("bGenerateChunks")))
	{
		if (bGenerateChunks)
		{
			UsePakFile = true;
		}
	}
	else if (Name == FName(TEXT("UsePakFile")))
	{
		if (!UsePakFile)
		{
			bGenerateChunks = false;
			bBuildHttpChunkInstallData = false;
		}
	}
	else if (Name == FName(TEXT("bBuildHTTPChunkInstallData")))
	{
		if (bBuildHttpChunkInstallData)
		{
			UsePakFile = true;
			bGenerateChunks = true;
			//Ensure data is something valid
			if (HttpChunkInstallDataDirectory.Path.IsEmpty())
			{
				auto CloudInstallDir = FPaths::ConvertRelativePathToFull(FPaths::GetPath(FPaths::GetProjectFilePath())) / TEXT("ChunkInstall");
				HttpChunkInstallDataDirectory.Path = CloudInstallDir;
			}

file
class        class FLauncherProfile final : public ILauncherProfile
function     virtual bool IsGeneratingChunks

	virtual bool IsGeneratingChunks() const override
	{
		return bGenerateChunks;
	}

	virtual bool IsGenerateHttpChunkData() const override
	{
		return bGenerateHttpChunkData;
	}

file
class        class FLauncherProfile final : public ILauncherProfile
function     virtual bool Serialize

		if (Version >= LAUNCHERSERVICES_ADDEDGENERATECHUNKS)
		{
			Archive << bGenerateChunks;
			Archive << bGenerateHttpChunkData;
			Archive << HttpChunkDataDirectory;
			Archive << HttpChunkDataReleaseName;
		}
		if (Version >= LAUNCHERSERVICES_ADDARCHIVE)
		{

file
class        class FLauncherProfile final : public ILauncherProfile
function     virtual void Save

		Writer.WriteValue("CreateDLC", CreateDLC);
		Writer.WriteValue("DLCName", DLCName);
		Writer.WriteValue("GenerateChunks", bGenerateChunks);
		Writer.WriteValue("GenerateHttpChunkData", bGenerateHttpChunkData);
		Writer.WriteValue("HttpChunkDataDirectory", HttpChunkDataDirectory);
		Writer.WriteValue("HttpChunkDataReleaseName", HttpChunkDataReleaseName);
		Writer.WriteValue("Archive", bArchive);
		Writer.WriteValue("ArchiveDirectory", ArchiveDir);
		Writer.WriteValue("AdditionalCommandLineParameters", AdditionalCommandLineParameters);

file
class        class FLauncherProfile final : public ILauncherProfile
function     virtual bool Load

		CreateDLC = Object.GetBoolField(TEXT("CreateDLC"));
		DLCName = Object.GetStringField(TEXT("DLCName"));
		bGenerateChunks = Object.GetBoolField(TEXT("GenerateChunks"));
		bGenerateHttpChunkData = Object.GetBoolField(TEXT("GenerateHttpChunkData"));
		HttpChunkDataDirectory = Object.GetStringField(TEXT("HttpChunkDataDirectory"));
		HttpChunkDataReleaseName = Object.GetStringField(TEXT("HttpChunkDataReleaseName"));

		if (Version >= LAUNCHERSERVICES_ADDARCHIVE)
		{

file
class        class FLauncherProfile final : public ILauncherProfile
function     virtual void SetDefaults

		DLCIncludeEngineContent = false;

		bGenerateChunks = false;
		bGenerateHttpChunkData = false;
		HttpChunkDataDirectory = TEXT("");
		HttpChunkDataReleaseName = TEXT("");

		// default launch settings
		DefaultDeployPlatform = NAME_None;

file
class        class FLauncherProfile final : public ILauncherProfile
function     virtual void SetGenerateChunks

	virtual void SetGenerateChunks(bool bInGenerateChunks) override
	{
		if (bGenerateChunks != bInGenerateChunks)
		{
			bGenerateChunks = bInGenerateChunks;
			Validate();
		}
	}

	virtual void SetGenerateHttpChunkData(bool bInGenerateHttpChunkData) override
	{

file
class        class FLauncherProfile final : public ILauncherProfile

	// Flag indicating if content should be split into chunks
	bool bGenerateChunks;
	
	// Flag indicating if chunked content should be used to generate HTTPChunkInstall data
	bool bGenerateHttpChunkData;
	
	// Where to store HTTPChunkInstall data
	FString HttpChunkDataDirectory;

file
class        class ILauncherProfile

	 * @param true if Chunks should be generated, false otherwise.
	 */
	virtual void SetGenerateChunks(bool bGenerateChunks) = 0;
	/**
	 * Set whether packaging will use chunk data to generate http chunk install data.
	 *
	 * @param true if data should be generated, false otherwise.
	 */
	virtual void SetGenerateHttpChunkData(bool bGenerateHttpChunkData) = 0;

file
class        class FTurnkeySupportCallbacks
function     static void CookOrPackage

			}

			if (PackagingSettings->bGenerateChunks)
			{
				BuildCookRunParams += TEXT(" -manifests");
			}

			// Whether to include the crash reporter.
			if (PackagingSettings->IncludeCrashReporter && PlatformInfo->DataDrivenPlatformInfo->bCanUseCrashReporter)

file
function     FAssetRegistryGenerator::FAssetRegistryGenerator

	: AssetRegistry(FModuleManager::LoadModuleChecked<FAssetRegistryModule>(TEXT("AssetRegistry")).Get())
	, TargetPlatform(InPlatform)
	, bGenerateChunks(false)
	, bClonedGlobalAssetRegistry(false)
	, HighestChunkId(0)
	, DependencyInfo(*GetMutableDefault<UChunkDependencyInfo>())
{
	LLM_SCOPE_BYTAG(Cooker_GeneratedAssetRegistry);
	bool bOnlyHardReferences = false;

file
function     void FAssetRegistryGenerator::CalculateChunkIdsAndAssignToManifest

	TArray<int32> ExistingChunkIDs;

	if (!bGenerateChunks)
	{
		TargetChunks.AddUnique(0);
		ExistingChunkIDs.AddUnique(0);
	}
	else
	{

file
function     bool FAssetRegistryGenerator::SaveManifests

{
	LLM_SCOPE_BYTAG(Cooker_GeneratedAssetRegistry);
	if (!bGenerateChunks)
	{
		return true;
	}

	if (!GenerateStreamingInstallManifest(InOverrideChunkSize, InManifestSubDir, InSandboxFile))
	{

file
function     void FAssetRegistryGenerator::FinalizeChunkIDs

	LLM_SCOPE_BYTAG(Cooker_GeneratedAssetRegistry);
	// bGenerateNoChunks overrides bGenerateStreamingInstallManifest overrides ShouldPlatformGenerateStreamingInstallManifest
	// bGenerateChunks means we allow chunks other than 0 based on package ChunkIds, AND we generate a manifest for each chunk
	const UProjectPackagingSettings* PackagingSettings = Cast<UProjectPackagingSettings>(UProjectPackagingSettings::StaticClass()->GetDefaultObject());
	if (PackagingSettings->bGenerateNoChunks)
	{
		bGenerateChunks = false;
	}
	else if (bGenerateStreamingInstallManifest)
	{
		bGenerateChunks = true;
	}
	else
	{
		bGenerateChunks = ShouldPlatformGenerateStreamingInstallManifest(TargetPlatform);
	}

	CookedPackages = InCookedPackages;
	DevelopmentOnlyPackages = InDevelopmentOnlyPackages;

	// Possibly apply previous AssetData and AssetPackageData for packages kept from a previous cook

file
function     bool FAssetRegistryGenerator::SaveAssetRegistry

		}

		if (bGenerateChunks)
		{
			FString ChunkListsPath = PlatformSandboxPath.Replace(*FString::Printf(TEXT("/%s"), DevelopmentAssetRegistryFilename), TEXT(""));

			// Write out CSV file with chunking information
			GenerateAssetChunkInformationCSV(ChunkListsPath, false);
		}

file
class        class FAssetRegistryGenerator

	TSet<FName> PackagesContainingMaps;
	/** Should the chunks be generated or only asset registry */
	bool bGenerateChunks;
	bool bClonedGlobalAssetRegistry;
	/** Highest chunk id, being used for geneating dependency tree */
	int32 HighestChunkId;
	/** Array of Maps with chunks<->packages assignments */
	TArray<TUniquePtr<FChunkPackageSet>> ChunkManifests;
	/** Map of packages that has not been assigned to chunks */

file
function     void UAssetManager::UpdateManagementDatabase

	UProjectPackagingSettings* ProjectPackagingSettings = GetMutableDefault<UProjectPackagingSettings>();
	if (ProjectPackagingSettings && ProjectPackagingSettings->bGenerateChunks)
	{
		// Update the editor preview chunk package list for all chunks, but only if we actually care about chunks
		// bGenerateChunks is settable per platform, but should be enabled on the default platform for preview to work
		TArray<int32> OverrideChunkList;
		for (FName PackageName : PackagesToUpdateChunksFor)
		{
			ChunkList.Reset();
			OverrideChunkList.Reset();
			GetPackageChunkIds(PackageName, nullptr, ExistingChunkList, ChunkList, &OverrideChunkList);

		{
			bool bSetting = false;
			if (GameConfig.GetBool(PackagingIniPath, "bGenerateChunks", out bSetting))
			{
				PlatformUsesChunkManifests = bSetting;
			}
		}
	}