You've already forked UnrealEngineUWP
mirror of
https://github.com/izzy2lost/UnrealEngineUWP.git
synced 2026-03-26 18:15:20 -07:00
b84453bc37
#rb chris.babcock,jack.porter #fyi chris.babcock,jack.porter [CL 15056295 by Josh Adams in ue5-main branch]
567 lines
18 KiB
C++
567 lines
18 KiB
C++
// Copyright Epic Games, Inc. All Rights Reserved.
|
|
|
|
/*=============================================================================
|
|
AndroidTargetPlatform.h: Declares the FAndroidTargetPlatform class.
|
|
=============================================================================*/
|
|
|
|
#pragma once
|
|
|
|
#include "CoreTypes.h"
|
|
#include "Containers/UnrealString.h"
|
|
#include "UObject/NameTypes.h"
|
|
#include "Delegates/IDelegateInstance.h"
|
|
#include "Containers/Map.h"
|
|
#include "Delegates/Delegate.h"
|
|
#include "Containers/Ticker.h"
|
|
#include "Misc/ScopeLock.h"
|
|
#include "Android/AndroidPlatformProperties.h"
|
|
#include "Interfaces/ITargetPlatformModule.h"
|
|
#include "Common/TargetPlatformBase.h"
|
|
#include "Interfaces/IAndroidDeviceDetection.h"
|
|
#include "Interfaces/IAndroidDeviceDetectionModule.h"
|
|
#include "AndroidTargetDevice.h"
|
|
|
|
#if WITH_ENGINE
|
|
#include "Engine/TextureCube.h"
|
|
#include "Internationalization/Text.h"
|
|
#include "StaticMeshResources.h"
|
|
#endif // WITH_ENGINE
|
|
|
|
#define LOCTEXT_NAMESPACE "FAndroidTargetPlatform"
|
|
|
|
class FTargetDeviceId;
|
|
class IAndroidDeviceDetection;
|
|
class ITargetPlatform;
|
|
class UTextureLODSettings;
|
|
enum class ETargetPlatformFeatures;
|
|
template<typename TPlatformProperties> class TTargetPlatformBase;
|
|
|
|
template< typename InElementType, typename KeyFuncs , typename Allocator > class TSet;
|
|
template<typename KeyType,typename ValueType,typename SetAllocator ,typename KeyFuncs > class TMap;
|
|
template<typename KeyType,typename ValueType,typename SetAllocator ,typename KeyFuncs > class TMultiMap;
|
|
template<typename TPlatformProperties> class TTargetPlatformBase;
|
|
|
|
/**
|
|
* Defines supported texture format names.
|
|
*/
|
|
namespace AndroidTexFormat
|
|
{
|
|
// Compressed Texture Formats
|
|
static FName NameDXT1(TEXT("DXT1"));
|
|
static FName NameDXT5(TEXT("DXT5"));
|
|
static FName NameAutoDXT(TEXT("AutoDXT"));
|
|
static FName NameETC2_RGB(TEXT("ETC2_RGB"));
|
|
static FName NameETC2_RGBA(TEXT("ETC2_RGBA"));
|
|
static FName NameAutoETC2(TEXT("AutoETC2"));
|
|
static FName NameASTC_4x4(TEXT("ASTC_4x4"));
|
|
static FName NameASTC_6x6(TEXT("ASTC_6x6"));
|
|
static FName NameASTC_8x8(TEXT("ASTC_8x8"));
|
|
static FName NameASTC_10x10(TEXT("ASTC_10x10"));
|
|
static FName NameASTC_12x12(TEXT("ASTC_12x12"));
|
|
static FName NameAutoASTC(TEXT("AutoASTC"));
|
|
|
|
// Uncompressed Texture Formats
|
|
static FName NameBGRA8(TEXT("BGRA8"));
|
|
static FName NameG8(TEXT("G8"));
|
|
static FName NameVU8(TEXT("VU8"));
|
|
static FName NameRGBA16F(TEXT("RGBA16F"));
|
|
static FName NameR16F(TEXT("R16F"));
|
|
|
|
// Error "formats" (uncompressed)
|
|
static FName NamePOTERROR(TEXT("POTERROR"));
|
|
}
|
|
|
|
/** Listed in order of priority...if device supports multiple formats, first format in list will be chosen */
|
|
enum class EAndroidTextureFormatCategory
|
|
{
|
|
DXT,
|
|
ETC2,
|
|
ASTC,
|
|
|
|
Count,
|
|
};
|
|
|
|
/**
|
|
* FAndroidTargetPlatform, abstraction for cooking Android platforms
|
|
*/
|
|
class ANDROIDTARGETPLATFORM_API FAndroidTargetPlatform : public TNonDesktopTargetPlatformBase<FAndroidPlatformProperties>
|
|
{
|
|
public:
|
|
|
|
/**
|
|
* Default constructor.
|
|
*/
|
|
FAndroidTargetPlatform(bool bIsClient, const TCHAR* FlavorName, const TCHAR* OverrideIniPlatformName=nullptr);
|
|
|
|
/**
|
|
* Destructor
|
|
*/
|
|
virtual ~FAndroidTargetPlatform();
|
|
|
|
public:
|
|
|
|
/**
|
|
* Gets the name of the Android platform variant, i.e. ASTC, ETC2, DXT, etc.
|
|
*
|
|
* @param Variant name.
|
|
*/
|
|
FString GetAndroidVariantName() const
|
|
{
|
|
return PlatformInfo->PlatformFlavor.ToString();
|
|
}
|
|
|
|
public:
|
|
|
|
//~ Begin ITargetPlatform Interface
|
|
|
|
virtual void EnableDeviceCheck(bool OnOff) override {}
|
|
|
|
virtual bool AddDevice( const FString& DeviceName, bool bDefault ) override
|
|
{
|
|
return false;
|
|
}
|
|
|
|
virtual void GetAllDevices( TArray<ITargetDevicePtr>& OutDevices ) const override;
|
|
|
|
virtual bool GenerateStreamingInstallManifest(const TMultiMap<FString, int32>& PakchunkMap, const TSet<int32>& PakchunkIndicesInUse) const override
|
|
{
|
|
return true;
|
|
}
|
|
|
|
virtual ITargetDevicePtr GetDefaultDevice( ) const override;
|
|
|
|
virtual ITargetDevicePtr GetDevice( const FTargetDeviceId& DeviceId ) override;
|
|
|
|
virtual bool IsSdkInstalled(bool bProjectHasCode, FString& OutDocumentationPath) const override;
|
|
|
|
virtual int32 CheckRequirements(bool bProjectHasCode, EBuildConfiguration Configuration, bool bRequiresAssetNativization, FString& OutTutorialPath, FString& OutDocumentationPath, FText& CustomizedLogMessage) const override;
|
|
|
|
virtual bool SupportsFeature( ETargetPlatformFeatures Feature ) const override;
|
|
|
|
virtual bool SupportsTextureFormat( FName Format ) const
|
|
{
|
|
// By default we support all texture formats.
|
|
return true;
|
|
}
|
|
|
|
virtual bool SupportsTextureFormatCategory(EAndroidTextureFormatCategory Category) const
|
|
{
|
|
return true;
|
|
}
|
|
|
|
virtual bool SupportsCompressedNonPOT( ) const
|
|
{
|
|
// most formats do support non-POT compressed textures
|
|
return true;
|
|
}
|
|
|
|
#if WITH_ENGINE
|
|
virtual void GetReflectionCaptureFormats( TArray<FName>& OutFormats ) const override;
|
|
|
|
virtual void GetAllPossibleShaderFormats( TArray<FName>& OutFormats ) const override;
|
|
|
|
virtual void GetAllTargetedShaderFormats(TArray<FName>& OutFormats) const override;
|
|
|
|
virtual const class FStaticMeshLODSettings& GetStaticMeshLODSettings() const override;
|
|
|
|
virtual void GetTextureFormats( const UTexture* InTexture, TArray< TArray<FName> >& OutFormats) const override;
|
|
|
|
virtual FName FinalizeVirtualTextureLayerFormat(FName Format) const override;
|
|
|
|
virtual void GetAllTextureFormats(TArray<FName>& OutFormats) const override;
|
|
|
|
virtual const UTextureLODSettings& GetTextureLODSettings() const override;
|
|
|
|
virtual void RegisterTextureLODSettings(const UTextureLODSettings* InTextureLODSettings) override
|
|
{
|
|
TextureLODSettings = InTextureLODSettings;
|
|
}
|
|
|
|
virtual FName GetWaveFormat( const class USoundWave* Wave ) const override;
|
|
virtual void GetAllWaveFormats( TArray<FName>& OutFormats) const override;
|
|
|
|
#endif //WITH_ENGINE
|
|
|
|
virtual bool SupportsVariants() const override;
|
|
|
|
virtual void GetBuildProjectSettingKeys(FString& OutSection, TArray<FString>& InBoolKeys, TArray<FString>& InIntKeys, TArray<FString>& InStringKeys) const override
|
|
{
|
|
OutSection = TEXT("/Script/AndroidRuntimeSettings.AndroidRuntimeSettings");
|
|
InBoolKeys.Add(TEXT("bBuildForArm64")); InBoolKeys.Add(TEXT("bBuildForX8664"));
|
|
InBoolKeys.Add(TEXT("bBuildForES31")); InBoolKeys.Add(TEXT("bBuildWithHiddenSymbolVisibility"));
|
|
InBoolKeys.Add(TEXT("bSaveSymbols")); InStringKeys.Add(TEXT("NDKAPILevel"));
|
|
}
|
|
|
|
virtual bool ShouldExpandTo32Bit(const uint16* Indices, const int32 NumIndices) const override;
|
|
//~ End ITargetPlatform Interface
|
|
|
|
virtual void InitializeDeviceDetection();
|
|
|
|
protected:
|
|
|
|
/**
|
|
* Adds the specified texture format to the OutFormats if this android target platforms supports it.
|
|
*
|
|
* @param Format - The format to add.
|
|
* @param OutFormats - The collection of formats to add to.
|
|
* @param bIsCompressedNonPOT - If this is true, the texture wants to be compressed but is not a power of 2
|
|
*/
|
|
void AddTextureFormatIfSupports( FName Format, TArray<FName>& OutFormats, bool bIsCompressedNonPOT=false ) const;
|
|
|
|
/**
|
|
* Return true if this device has a supported set of extensions for this platform.
|
|
*
|
|
* @param Extensions - The GL extensions string.
|
|
* @param GLESVersion - The GLES version reported by this device.
|
|
*/
|
|
virtual bool SupportedByExtensionsString( const FString& ExtensionsString, const int GLESVersion ) const
|
|
{
|
|
return true;
|
|
}
|
|
|
|
virtual FAndroidTargetDevicePtr CreateTargetDevice(const ITargetPlatform& InTargetPlatform, const FString& InSerialNumber, const FString& InAndroidVariant) const;
|
|
|
|
// query for rene3ring mode support
|
|
bool SupportsES31() const;
|
|
bool SupportsVulkan() const;
|
|
bool SupportsSoftwareOcclusion() const;
|
|
bool SupportsLandscapeMeshLODStreaming() const;
|
|
bool SupportsVulkanSM5() const;
|
|
|
|
protected:
|
|
|
|
// Handles when the ticker fires.
|
|
bool HandleTicker( float DeltaTime );
|
|
|
|
virtual FAndroidTargetDeviceRef CreateNewDevice(const FAndroidDeviceInfo &DeviceInfo);
|
|
|
|
// Holds a map of valid devices.
|
|
TMap<FString, FAndroidTargetDevicePtr> Devices;
|
|
|
|
// Holds a delegate to be invoked when the widget ticks.
|
|
FTickerDelegate TickDelegate;
|
|
|
|
// Handle to the registered TickDelegate.
|
|
FDelegateHandle TickDelegateHandle;
|
|
|
|
// Pointer to the device detection handler that grabs device ids in another thread
|
|
IAndroidDeviceDetection* DeviceDetection;
|
|
|
|
#if WITH_ENGINE
|
|
// Holds a cache of the target LOD settings.
|
|
const UTextureLODSettings* TextureLODSettings;
|
|
|
|
// Holds the static mesh LOD settings.
|
|
FStaticMeshLODSettings StaticMeshLODSettings;
|
|
|
|
ITargetDevicePtr DefaultDevice;
|
|
#endif //WITH_ENGINE
|
|
};
|
|
|
|
|
|
//#include "AndroidTargetPlatform.inl"
|
|
|
|
|
|
class FAndroid_DXTTargetPlatform : public FAndroidTargetPlatform
|
|
{
|
|
public:
|
|
FAndroid_DXTTargetPlatform(bool bIsClient) : FAndroidTargetPlatform(bIsClient, TEXT("DXT"))
|
|
{
|
|
}
|
|
|
|
virtual bool SupportsTextureFormat(FName Format) const override
|
|
{
|
|
if (Format == AndroidTexFormat::NameDXT1 ||
|
|
Format == AndroidTexFormat::NameDXT5 ||
|
|
Format == AndroidTexFormat::NameAutoDXT)
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
virtual bool SupportsTextureFormatCategory(EAndroidTextureFormatCategory Category) const override
|
|
{
|
|
return Category == EAndroidTextureFormatCategory::DXT;
|
|
}
|
|
|
|
virtual bool SupportedByExtensionsString(const FString& ExtensionsString, const int GLESVersion) const override
|
|
{
|
|
return (ExtensionsString.Contains(TEXT("GL_NV_texture_compression_s3tc")) || ExtensionsString.Contains(TEXT("GL_EXT_texture_compression_s3tc")));
|
|
}
|
|
|
|
virtual float GetVariantPriority() const override
|
|
{
|
|
float Priority;
|
|
return (GConfig->GetFloat(TEXT("/Script/AndroidRuntimeSettings.AndroidRuntimeSettings"), TEXT("TextureFormatPriority_DXT"), Priority, GEngineIni) ?
|
|
Priority : 0.6f) * 10.0f + (IsClientOnly() ? 0.25f : 0.5f);
|
|
}
|
|
};
|
|
|
|
|
|
class FAndroid_ASTCTargetPlatform : public FAndroidTargetPlatform
|
|
{
|
|
public:
|
|
FAndroid_ASTCTargetPlatform(bool bIsClient) : FAndroidTargetPlatform(bIsClient, TEXT("ASTC"))
|
|
{
|
|
}
|
|
|
|
virtual bool SupportsTextureFormat(FName Format) const override
|
|
{
|
|
if (Format == AndroidTexFormat::NameASTC_4x4 ||
|
|
Format == AndroidTexFormat::NameASTC_6x6 ||
|
|
Format == AndroidTexFormat::NameASTC_8x8 ||
|
|
Format == AndroidTexFormat::NameASTC_10x10 ||
|
|
Format == AndroidTexFormat::NameASTC_12x12 ||
|
|
Format == AndroidTexFormat::NameAutoASTC)
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
virtual bool SupportsTextureFormatCategory(EAndroidTextureFormatCategory Category) const override
|
|
{
|
|
return Category == EAndroidTextureFormatCategory::ASTC;
|
|
}
|
|
|
|
#if WITH_ENGINE
|
|
virtual void GetTextureFormats(const UTexture* Texture, TArray< TArray<FName> >& OutFormats) const
|
|
{
|
|
check(Texture);
|
|
|
|
// we remap some of the defaults (with ASTC formats)
|
|
static FName FormatRemap[][2] =
|
|
{
|
|
// Default format: ASTC format:
|
|
{ { FName(TEXT("DXT1")) }, { FName(TEXT("ASTC_RGB")) } },
|
|
{ { FName(TEXT("DXT5")) }, { FName(TEXT("ASTC_RGBA")) } },
|
|
{ { FName(TEXT("DXT5n")) }, { FName(TEXT("ASTC_NormalAG")) } },
|
|
{ { FName(TEXT("BC5")) }, { FName(TEXT("ASTC_NormalRG")) } },
|
|
{ { FName(TEXT("BC6H")) }, { FName(TEXT("ASTC_RGB")) } },
|
|
{ { FName(TEXT("BC7")) }, { FName(TEXT("ASTC_RGBAuto")) } },
|
|
{ { FName(TEXT("AutoDXT")) }, { FName(TEXT("ASTC_RGBAuto")) } },
|
|
};
|
|
|
|
GetDefaultTextureFormatNamePerLayer(OutFormats.AddDefaulted_GetRef(), this, Texture, true, false, 1);
|
|
|
|
for (FName& TextureFormatName : OutFormats.Last())
|
|
{
|
|
if (Texture->LODGroup == TEXTUREGROUP_Shadowmap)
|
|
{
|
|
// forward rendering only needs one channel for shadow maps
|
|
TextureFormatName = FName(TEXT("G8"));
|
|
}
|
|
else
|
|
{
|
|
// perform any remapping away from defaults
|
|
for (int32 RemapIndex = 0; RemapIndex < UE_ARRAY_COUNT(FormatRemap); ++RemapIndex)
|
|
{
|
|
if (TextureFormatName == FormatRemap[RemapIndex][0])
|
|
{
|
|
// we found a remapping
|
|
TextureFormatName = FormatRemap[RemapIndex][1];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
if (Texture->IsA(UTextureCube::StaticClass()))
|
|
{
|
|
const UTextureCube* Cube = CastChecked<UTextureCube>(Texture);
|
|
if (Cube != nullptr)
|
|
{
|
|
FTextureFormatSettings FormatSettings;
|
|
Cube->GetDefaultFormatSettings(FormatSettings);
|
|
if (FormatSettings.CompressionSettings == TC_ReflectionCapture && !FormatSettings.CompressionNone)
|
|
{
|
|
TextureFormatName = FName(TEXT("ETC2_RGBA"));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
virtual void GetAllTextureFormats(TArray<FName>& OutFormats) const override
|
|
{
|
|
// we remap some of the defaults (with ASTC formats)
|
|
static FName FormatRemap[][2] =
|
|
{
|
|
// Default format: ASTC format:
|
|
{ { FName(TEXT("DXT1")) }, { FName(TEXT("ASTC_RGB")) } },
|
|
{ { FName(TEXT("DXT5")) }, { FName(TEXT("ASTC_RGBA")) } },
|
|
{ { FName(TEXT("DXT5n")) }, { FName(TEXT("ASTC_NormalAG")) } },
|
|
{ { FName(TEXT("BC5")) }, { FName(TEXT("ASTC_NormalRG")) } },
|
|
{ { FName(TEXT("BC6H")) }, { FName(TEXT("ASTC_RGB")) } },
|
|
{ { FName(TEXT("BC7")) }, { FName(TEXT("ASTC_RGBAuto")) } },
|
|
{ { FName(TEXT("AutoDXT")) }, { FName(TEXT("ASTC_RGBAuto")) } },
|
|
};
|
|
|
|
GetAllDefaultTextureFormats(this, OutFormats, true);
|
|
|
|
for (int32 RemapIndex = 0; RemapIndex < UE_ARRAY_COUNT(FormatRemap); ++RemapIndex)
|
|
{
|
|
OutFormats.Remove(FormatRemap[RemapIndex][0]);
|
|
OutFormats.AddUnique(FormatRemap[RemapIndex][1]);
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
virtual bool SupportedByExtensionsString(const FString& ExtensionsString, const int GLESVersion) const override
|
|
{
|
|
return ExtensionsString.Contains(TEXT("GL_KHR_texture_compression_astc_ldr"));
|
|
}
|
|
|
|
virtual float GetVariantPriority() const override
|
|
{
|
|
float Priority;
|
|
return (GConfig->GetFloat(TEXT("/Script/AndroidRuntimeSettings.AndroidRuntimeSettings"), TEXT("TextureFormatPriority_ASTC"), Priority, GEngineIni) ?
|
|
Priority : 0.9f) * 10.0f + (IsClientOnly() ? 0.25f : 0.5f);
|
|
}
|
|
};
|
|
|
|
|
|
class FAndroid_ETC2TargetPlatform : public FAndroidTargetPlatform
|
|
{
|
|
public:
|
|
|
|
FAndroid_ETC2TargetPlatform(bool bIsClient) : FAndroidTargetPlatform(bIsClient, TEXT("ETC2"))
|
|
{
|
|
}
|
|
|
|
virtual bool SupportsTextureFormat(FName Format) const override
|
|
{
|
|
if (Format == AndroidTexFormat::NameETC2_RGB ||
|
|
Format == AndroidTexFormat::NameETC2_RGBA ||
|
|
Format == AndroidTexFormat::NameAutoETC2)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
virtual bool SupportsTextureFormatCategory(EAndroidTextureFormatCategory Category) const override
|
|
{
|
|
return Category == EAndroidTextureFormatCategory::ETC2;
|
|
}
|
|
|
|
virtual bool SupportedByExtensionsString(const FString& ExtensionsString, const int GLESVersion) const override
|
|
{
|
|
return GLESVersion >= 0x30000;
|
|
}
|
|
|
|
virtual float GetVariantPriority() const override
|
|
{
|
|
float Priority;
|
|
return (GConfig->GetFloat(TEXT("/Script/AndroidRuntimeSettings.AndroidRuntimeSettings"), TEXT("TextureFormatPriority_ETC2"), Priority, GEngineIni) ?
|
|
Priority : 0.2f) * 10.0f + (IsClientOnly() ? 0.25f : 0.5f);
|
|
}
|
|
};
|
|
|
|
class FAndroid_MultiTargetPlatform : public FAndroidTargetPlatform
|
|
{
|
|
TArray<ITargetPlatform*> FormatTargetPlatforms;
|
|
FString FormatTargetString;
|
|
|
|
public:
|
|
FAndroid_MultiTargetPlatform(bool bIsClient) : FAndroidTargetPlatform(bIsClient, TEXT("Multi"))
|
|
{
|
|
}
|
|
|
|
// set up all of the multiple formats together into this one
|
|
void LoadFormats(TArray<FAndroidTargetPlatform*> SingleFormatTPs)
|
|
{
|
|
// sort formats by priority so higher priority formats are packaged (and thus used by the device) first
|
|
// note that we passed this by value, not ref, so we can sort it
|
|
SingleFormatTPs.Sort([](const FAndroidTargetPlatform& A, const FAndroidTargetPlatform& B)
|
|
{
|
|
float PriorityA = 0.f;
|
|
float PriorityB = 0.f;
|
|
FString VariantA = A.GetAndroidVariantName().Replace(TEXT("Client"), TEXT(""));
|
|
FString VariantB = B.GetAndroidVariantName().Replace(TEXT("Client"), TEXT(""));
|
|
GConfig->GetFloat(TEXT("/Script/AndroidRuntimeSettings.AndroidRuntimeSettings"), *(FString(TEXT("TextureFormatPriority_")) + VariantA), PriorityA, GEngineIni);
|
|
GConfig->GetFloat(TEXT("/Script/AndroidRuntimeSettings.AndroidRuntimeSettings"), *(FString(TEXT("TextureFormatPriority_")) + VariantB), PriorityB, GEngineIni);
|
|
return PriorityA > PriorityB;
|
|
});
|
|
|
|
FormatTargetPlatforms.Empty();
|
|
FormatTargetString = TEXT("");
|
|
|
|
TSet<FString> SeenFormats;
|
|
|
|
// Load the TargetPlatform module for each format
|
|
for (FAndroidTargetPlatform* SingleFormatTP : SingleFormatTPs)
|
|
{
|
|
// only use once each
|
|
if (SeenFormats.Contains(SingleFormatTP->GetAndroidVariantName()))
|
|
{
|
|
continue;
|
|
}
|
|
SeenFormats.Add(SingleFormatTP->GetAndroidVariantName());
|
|
|
|
bool bEnabled = false;
|
|
FString SettingsName = FString(TEXT("bMultiTargetFormat_")) + *SingleFormatTP->GetAndroidVariantName();
|
|
GConfig->GetBool(TEXT("/Script/AndroidRuntimeSettings.AndroidRuntimeSettings"), *SettingsName, bEnabled, GEngineIni);
|
|
if (bEnabled)
|
|
{
|
|
if (FormatTargetPlatforms.Num())
|
|
{
|
|
FormatTargetString += TEXT(",");
|
|
}
|
|
FormatTargetString += SingleFormatTP->GetAndroidVariantName();
|
|
FormatTargetPlatforms.Add(SingleFormatTP);
|
|
}
|
|
}
|
|
|
|
// @todo do we need this with DisplayName below?
|
|
PlatformInfo::UpdatePlatformDisplayName(TEXT("Android_Multi"), DisplayName());
|
|
}
|
|
|
|
virtual FText DisplayName() const override
|
|
{
|
|
return FText::Format(LOCTEXT("Android_Multi", "Android (Multi:{0})"), FText::FromString(FormatTargetString));
|
|
}
|
|
|
|
#if WITH_ENGINE
|
|
virtual void GetTextureFormats(const UTexture* Texture, TArray< TArray<FName> >& OutFormats) const
|
|
{
|
|
// Ask each platform variant to choose texture formats
|
|
for (ITargetPlatform* Platform : FormatTargetPlatforms)
|
|
{
|
|
TArray< TArray<FName> > PlatformFormats;
|
|
Platform->GetTextureFormats(Texture, PlatformFormats);
|
|
for (const TArray<FName>& FormatPerLayer : PlatformFormats)
|
|
{
|
|
OutFormats.AddUnique(FormatPerLayer);
|
|
}
|
|
}
|
|
}
|
|
|
|
virtual void GetAllTextureFormats(TArray<FName>& OutFormats) const override
|
|
{
|
|
// Ask each platform variant to choose texture formats
|
|
for (ITargetPlatform* Platform : FormatTargetPlatforms)
|
|
{
|
|
TArray<FName> PlatformFormats;
|
|
Platform->GetAllTextureFormats(PlatformFormats);
|
|
for (FName Format : PlatformFormats)
|
|
{
|
|
OutFormats.AddUnique(Format);
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
virtual float GetVariantPriority() const override
|
|
{
|
|
// lowest priority so specific variants are chosen first
|
|
return (IsClientOnly() ? 0.25f : 0.5f);
|
|
}
|
|
};
|
|
|
|
#undef LOCTEXT_NAMESPACE
|