public static void OnPostprocessScene()
{
// Debug.Log("OnPostprocessScene");
if (Application.isPlaying)
{
return;
}
BuildTarget BT = EditorUserBuildSettings.activeBuildTarget;
if (BT != BuildTarget.iOS)
{
return;
}
List <GraphicsDeviceType> gdtl = PlayerSettings.GetGraphicsAPIs(BT).Where(api => api != GraphicsDeviceType.Metal).ToList();
//gdtl.ForEach(x=> {Debug.Log(x);});
if (PlayerSettings.GetUseDefaultGraphicsAPIs(BT))
{
Debug.LogWarning("<color='red'>MPMP</color>: Auto Graphics API is selected in your publish settings! Removing Metal as build option.");
PlayerSettings.SetUseDefaultGraphicsAPIs(BT, false);
}
else if (PlayerSettings.GetGraphicsAPIs(BT).Contains(GraphicsDeviceType.Metal))
{
Debug.LogWarning("<color='red'>MPMP</color>: Removing Metal as build option.");
}
//gdtl.ForEach(x=> {Debug.Log(x);});
PlayerSettings.SetGraphicsAPIs(BT, gdtl.ToArray());
}
bool ValidateRendererGraphicsAPIs(UniversalRenderPipelineAsset pipelineAsset, out string unsupportedGraphicsApisMessage)
{
// Check the list of Renderers against all Graphics APIs the player is built with.
unsupportedGraphicsApisMessage = null;
BuildTarget platform = EditorUserBuildSettings.activeBuildTarget;
GraphicsDeviceType[] graphicsAPIs = PlayerSettings.GetGraphicsAPIs(platform);
int rendererCount = pipelineAsset.m_RendererDataList.Length;
for (int i = 0; i < rendererCount; i++)
{
ScriptableRenderer renderer = pipelineAsset.GetRenderer(i);
if (renderer == null)
{
continue;
}
GraphicsDeviceType[] unsupportedAPIs = renderer.unsupportedGraphicsDeviceTypes;
for (int apiIndex = 0; apiIndex < unsupportedAPIs.Length; apiIndex++)
{
if (System.Array.FindIndex(graphicsAPIs, element => element == unsupportedAPIs[apiIndex]) >= 0)
{
unsupportedGraphicsApisMessage += System.String.Format("{0} at index {1} does not support {2}.\n", renderer, i, unsupportedAPIs[apiIndex]);
}
}
}
return(unsupportedGraphicsApisMessage == null);
}
internal static SimulationPlayerSettings InitDefaultPlayerSettings()
{
var defaultPlayerSettings = new SimulationPlayerSettings();
var serializedSettings = PlayerSettings.GetSerializedObject();
serializedSettings.Update();
defaultPlayerSettings.resolutionScalingMode = (ResolutionScalingMode)serializedSettings.FindProperty("resolutionScalingMode").intValue;
defaultPlayerSettings.targetDpi = serializedSettings.FindProperty("targetPixelDensity").intValue;
defaultPlayerSettings.androidStartInFullscreen = serializedSettings.FindProperty("androidStartInFullscreen").boolValue;
defaultPlayerSettings.defaultOrientation = PlayerSettings.defaultInterfaceOrientation;
defaultPlayerSettings.allowedPortrait = PlayerSettings.allowedAutorotateToPortrait;
defaultPlayerSettings.allowedPortraitUpsideDown = PlayerSettings.allowedAutorotateToPortraitUpsideDown;
defaultPlayerSettings.allowedLandscapeLeft = PlayerSettings.allowedAutorotateToLandscapeLeft;
defaultPlayerSettings.allowedLandscapeRight = PlayerSettings.allowedAutorotateToLandscapeRight;
if (!PlayerSettings.GetUseDefaultGraphicsAPIs(BuildTarget.Android))
{
defaultPlayerSettings.androidGraphicsAPIs = PlayerSettings.GetGraphicsAPIs(BuildTarget.Android);
}
if (!PlayerSettings.GetUseDefaultGraphicsAPIs(BuildTarget.iOS))
{
defaultPlayerSettings.iOSGraphicsAPIs = PlayerSettings.GetGraphicsAPIs(BuildTarget.iOS);
}
return(defaultPlayerSettings);
}
static void SetGraphicsAPIs(BuildTarget platform, bool auto, UnityEngine.Rendering.GraphicsDeviceType[] allowedTypes = null)
{
try
{
if (auto != PlayerSettings.GetUseDefaultGraphicsAPIs(platform))
{
PlayerSettings.SetUseDefaultGraphicsAPIs(platform, auto);
}
}
catch { }
try
{
UnityEngine.Rendering.GraphicsDeviceType[] graphicsAPIs = PlayerSettings.GetGraphicsAPIs(platform);
if (((allowedTypes == null || allowedTypes.Length == 0) &&
(graphicsAPIs != null || graphicsAPIs.Length != 0)) ||
!allowedTypes.SequenceEqual(graphicsAPIs))
{
if (allowedTypes == null)
{
allowedTypes = PlayerSettings.GetGraphicsAPIs(platform);
}
PlayerSettings.SetGraphicsAPIs(platform, allowedTypes);
}
}
catch { }
}
public static BuildHash BuildHashInfo(BuildAssetBundleOptions varBuildOption)
{
var tempHash = new BuildHash();
tempHash.BuildPlatform = EditorUserBuildSettings.activeBuildTarget;
tempHash.BuildSubPlatform = GetActiveSubtargetFor(tempHash.BuildPlatform);
tempHash.GraphicsAPIs = PlayerSettings.GetGraphicsAPIs(tempHash.BuildPlatform);
//shaderPlatforms;
tempHash.ShaderCompilerPlatforms = ShaderCompilerPlatformFromGfxDeviceRenderer(tempHash.GraphicsAPIs);
//TODO - GetShaderCompilerBackendVersion();
tempHash.stripUnusedMeshComponents = PlayerSettings.stripUnusedMeshComponents;
tempHash.AssetBundleBuildOptions = varBuildOption
& ~BuildAssetBundleOptions.ForceRebuildAssetBundle & ~BuildAssetBundleOptions.IgnoreTypeTreeChanges
& ~BuildAssetBundleOptions.AppendHashToAssetBundleName & ~BuildAssetBundleOptions.DryRunBuild;
var tempSceneGUIDs = AssetDatabase.FindAssets("t:Scene");
if (tempSceneGUIDs.Length != 0)
{
var tempBuildTags = new List <BuildUsageTagGlobal>(tempSceneGUIDs.Length);
foreach (var tempGUID in tempSceneGUIDs)
{
var tempPath = AssetDatabase.GUIDToAssetPath(tempGUID);
var tempUScene = EditorSceneManager.OpenScene(tempPath, OpenSceneMode.Single);
tempBuildTags.Add(GetSceneBuildUsageTag(tempUScene));
}
tempHash.BuildUsageTagGlobals = tempBuildTags.ToArray();
}
return(tempHash);
}
private static void CheckGraphicsAPI()
{
#if UNITY_IOS
#if UNITY_5 || UNITY_4_6 && !UNITY_4_6_1 && !UNITY_4_6_2
#if UNITY_5
var iOSBuildTarget = BuildTarget.iOS;
var iOSGraphicsAPIs = PlayerSettings.GetGraphicsAPIs(BuildTarget.iOS);
bool isOpenGL = true;
foreach (var device in iOSGraphicsAPIs)
{
isOpenGL &= (device == GraphicsDeviceType.OpenGLES2 || device == GraphicsDeviceType.OpenGLES3);
}
#else
var iOSBuildTarget = BuildTarget.iPhone;
bool isOpenGL = PlayerSettings.targetIOSGraphics == TargetIOSGraphics.OpenGLES_2_0 ||
PlayerSettings.targetIOSGraphics == TargetIOSGraphics.OpenGLES_3_0;
#endif // UNITY_5
if (EditorUserBuildSettings.activeBuildTarget == iOSBuildTarget &&
!Application.isPlaying &&
Object.FindObjectOfType <Cardboard>() != null &&
!isOpenGL)
{
Debug.LogWarning("iOS Graphics API should be set to OpenGL for best " +
"distortion-correction performance in Cardboard.");
}
#endif // UNITY_5 || UNITY_4_6 && !UNITY_4_6_1 && !UNITY_4_6_2
#endif // UNITY_IOS
}
static bool PlayerCheck()
{
bool isApply = true;
if (PlayerSettings.Android.minSdkVersion < AndroidSdkVersions.AndroidApiLevel24)
{
isApply = false;
}
if (PlayerSettings.GetApiCompatibilityLevel(BuildTargetGroup.Android) != ApiCompatibilityLevel.NET_4_6)
{
isApply = false;
}
if (PlayerSettings.GetMobileMTRendering(BuildTargetGroup.Android) == true)
{
isApply = false;
}
UnityEngine.Rendering.GraphicsDeviceType[] gapi = PlayerSettings.GetGraphicsAPIs(BuildTarget.Android);
if (gapi.Length != 1 || gapi[0] != UnityEngine.Rendering.GraphicsDeviceType.OpenGLES3)
{
isApply = false;
}
if (PlayerSettings.defaultInterfaceOrientation != UIOrientation.LandscapeLeft)
{
isApply = false;
}
return(isApply);
}
public SimulationPlayerSettings()
{
var serializedSettings = PlayerSettings.GetSerializedObject();
serializedSettings.Update();
resolutionScalingMode = (ResolutionScalingMode)serializedSettings.FindProperty("resolutionScalingMode").intValue;
targetDpi = serializedSettings.FindProperty("targetPixelDensity").intValue;
androidStartInFullscreen = serializedSettings.FindProperty("androidStartInFullscreen").boolValue;
androidRenderOutsideSafeArea = serializedSettings.FindProperty("androidRenderOutsideSafeArea").boolValue;
defaultOrientation = PlayerSettings.defaultInterfaceOrientation;
allowedPortrait = PlayerSettings.allowedAutorotateToPortrait;
allowedPortraitUpsideDown = PlayerSettings.allowedAutorotateToPortraitUpsideDown;
allowedLandscapeLeft = PlayerSettings.allowedAutorotateToLandscapeLeft;
allowedLandscapeRight = PlayerSettings.allowedAutorotateToLandscapeRight;
if (!PlayerSettings.GetUseDefaultGraphicsAPIs(BuildTarget.Android))
{
androidGraphicsAPIs = PlayerSettings.GetGraphicsAPIs(BuildTarget.Android);
}
if (!PlayerSettings.GetUseDefaultGraphicsAPIs(BuildTarget.iOS))
{
iOSGraphicsAPIs = PlayerSettings.GetGraphicsAPIs(BuildTarget.iOS);
}
}
public void OnPreprocessBuild(BuildReport report)
{
if (!OculusBuildTools.OculusLoaderPresentInSettingsForBuildTarget(report.summary.platformGroup))
{
return;
}
if (report.summary.platformGroup == BuildTargetGroup.Android)
{
GraphicsDeviceType firstGfxType = PlayerSettings.GetGraphicsAPIs(report.summary.platform)[0];
if (firstGfxType != GraphicsDeviceType.OpenGLES3 && firstGfxType != GraphicsDeviceType.Vulkan && firstGfxType != GraphicsDeviceType.OpenGLES2)
{
throw new BuildFailedException("OpenGLES2, OpenGLES3, and Vulkan are currently the only graphics APIs compatible with the Oculus XR Plugin on mobile platforms.");
}
if (PlayerSettings.Android.minSdkVersion < AndroidSdkVersions.AndroidApiLevel23)
{
throw new BuildFailedException("Android Minimum API Level must be set to 23 or higher for the Oculus XR Plugin.");
}
}
if (report.summary.platform == BuildTarget.StandaloneWindows || report.summary.platform == BuildTarget.StandaloneWindows64)
{
if (PlayerSettings.GetGraphicsAPIs(report.summary.platform)[0] !=
GraphicsDeviceType.Direct3D11)
{
throw new BuildFailedException("D3D11 is currently the only graphics API compatible with the Oculus XR Plugin on desktop platforms. Please change the Graphics API setting in Player Settings.");
}
}
}
void FixDXRDirect3D12(bool fromAsyncUnused)
{
if (GetSupportedGraphicsAPIs(CalculateSelectedBuildTarget()).Contains(GraphicsDeviceType.Direct3D12))
{
var buidTarget = CalculateSelectedBuildTarget();
if (PlayerSettings.GetGraphicsAPIs(buidTarget).Contains(GraphicsDeviceType.Direct3D12))
{
PlayerSettings.SetGraphicsAPIs(
buidTarget,
new[] { GraphicsDeviceType.Direct3D12 }
.Concat(
PlayerSettings.GetGraphicsAPIs(buidTarget)
.Where(x => x != GraphicsDeviceType.Direct3D12))
.ToArray());
}
else
{
PlayerSettings.SetGraphicsAPIs(
buidTarget,
new[] { GraphicsDeviceType.Direct3D12 }
.Concat(PlayerSettings.GetGraphicsAPIs(buidTarget))
.ToArray());
}
HDProjectSettings.wizardNeedRestartAfterChangingToDX12 = true;
m_Fixer.Add(() => ChangedFirstGraphicAPI(buidTarget)); //register reboot at end of operations
}
}
private static bool AreAPIsSelected(GraphicsDeviceType[] supported, BuildTarget target)
{
bool supportedAPI = true;
GraphicsDeviceType[] selected = PlayerSettings.GetGraphicsAPIs(target);
if (selected.Length == supported.Length)
{
int i = 0;
while (supportedAPI && i < selected.Length)
{
// Check this API support
bool IsInividualAPISupported = false;
int j = 0;
GraphicsDeviceType current = selected[i];
while (!IsInividualAPISupported && j < supported.Length)
{
IsInividualAPISupported = (current == supported[j]);
j++;
}
supportedAPI = IsInividualAPISupported;
i++;
}
}
else
{
supportedAPI = false;
}
return(supportedAPI);
}
static bool ValidateRendererGraphicsAPIsForLightLayers(UniversalRenderPipelineAsset pipelineAsset, out string unsupportedGraphicsApisMessage)
{
unsupportedGraphicsApisMessage = null;
BuildTarget platform = EditorUserBuildSettings.activeBuildTarget;
GraphicsDeviceType[] graphicsAPIs = PlayerSettings.GetGraphicsAPIs(platform);
for (int apiIndex = 0; apiIndex < graphicsAPIs.Length; apiIndex++)
{
if (!RenderingUtils.SupportsLightLayers(graphicsAPIs[apiIndex]))
{
if (unsupportedGraphicsApisMessage != null)
{
unsupportedGraphicsApisMessage += ", ";
}
unsupportedGraphicsApisMessage += System.String.Format("{0}", graphicsAPIs[apiIndex]);
}
}
if (unsupportedGraphicsApisMessage != null)
{
unsupportedGraphicsApisMessage += ".";
}
return(unsupportedGraphicsApisMessage == null);
}
public void OnPreprocessBuild(BuildReport report)
{
if (!PXR_BuildTools.LoaderPresentInSettingsForBuildTarget(report.summary.platformGroup))
{
return;
}
if (report.summary.platformGroup == BuildTargetGroup.Android)
{
GraphicsDeviceType firstGfxType = PlayerSettings.GetGraphicsAPIs(EditorUserBuildSettings.activeBuildTarget)[0];
if (firstGfxType != GraphicsDeviceType.OpenGLES3 && firstGfxType != GraphicsDeviceType.Vulkan && firstGfxType != GraphicsDeviceType.OpenGLES2)
{
throw new BuildFailedException("OpenGLES2, OpenGLES3, and Vulkan are currently the only graphics APIs compatible with the PicoVR XR Plugin on mobile platforms.");
}
if (PXR_BuildTools.GetSettings().stereoRenderingModeAndroid == PXR_Settings.StereoRenderingModeAndroid.Multiview && firstGfxType == GraphicsDeviceType.OpenGLES2)
{
PlayerSettings.SetGraphicsAPIs(BuildTarget.Android, new GraphicsDeviceType[] { GraphicsDeviceType.OpenGLES3 });
}
if (PlayerSettings.Android.minSdkVersion < AndroidSdkVersions.AndroidApiLevel26)
{
throw new BuildFailedException("Minimum API must be set to 26 or higher for Pico XR Plugin.");
}
PlayerSettings.Android.forceSDCardPermission = true;
}
}
void FixDXRDirect3D12(bool fromAsync)
{
if (GetSupportedGraphicsAPIs(CalculateSelectedBuildTarget()).Contains(GraphicsDeviceType.Direct3D12))
{
var buidTarget = CalculateSelectedBuildTarget();
if (PlayerSettings.GetGraphicsAPIs(buidTarget).Contains(GraphicsDeviceType.Direct3D12))
{
PlayerSettings.SetGraphicsAPIs(
buidTarget,
new[] { GraphicsDeviceType.Direct3D12 }
.Concat(
PlayerSettings.GetGraphicsAPIs(buidTarget)
.Where(x => x != GraphicsDeviceType.Direct3D12))
.ToArray());
}
else
{
PlayerSettings.SetGraphicsAPIs(
buidTarget,
new[] { GraphicsDeviceType.Direct3D12 }
.Concat(PlayerSettings.GetGraphicsAPIs(buidTarget))
.ToArray());
}
if (fromAsync)
{
m_Fixer.Stop();
}
ChangedFirstGraphicAPI(buidTarget);
}
}
public void SetupPlayerSettings()
{
SetupBase();
GraphicsDeviceType[] deviceTypes = PlayerSettings.GetGraphicsAPIs(BuildTarget.StandaloneOSX);
var oldGfxType = m_PlayerSettingsDeviceType;
// If the type we want to check isn't the supported graphics type, then substitute it out
// so we can still pass the tests. Semantics are the same regardless of actual devices.
if (SystemInfo.graphicsDeviceType != m_PlayerSettingsDeviceType)
{
m_PlayerSettingsDeviceType = SystemInfo.graphicsDeviceType;
for (int i = 0; i < m_LoadersSupporteDeviceTypes.Length; i++)
{
if (oldGfxType == m_LoadersSupporteDeviceTypes[i])
{
m_LoadersSupporteDeviceTypes[i] = m_PlayerSettingsDeviceType;
}
}
}
#if UNITY_EDITOR_WIN
PlayerSettings.SetGraphicsAPIs(BuildTarget.StandaloneWindows64, new[] { m_PlayerSettingsDeviceType });
#elif UNITY_EDITOR_OSX
PlayerSettings.SetGraphicsAPIs(BuildTarget.StandaloneOSX, new[] { m_PlayerSettingsDeviceType });
#endif
for (var i = 0; i < loaderCount; ++i)
{
var dl = loaders[i] as DummyLoader;
dl.shouldFail = (i != m_LoaderIndexToWin);
dl.supportedDeviceType = m_LoadersSupporteDeviceTypes[i];
}
}
public bool PlayerSettingsGraphicsAPIs_iOS_OpenGLES()
{
var graphicsAPIs = PlayerSettings.GetGraphicsAPIs(BuildTarget.iOS);
var hasMetal = graphicsAPIs.Contains(GraphicsDeviceType.Metal);
return(!hasMetal);
}
void BuildAndroid(BuildQueueItem buildQueueItem)
{
BuildPlayerOptions buildPlayerOptions = new BuildPlayerOptions();
// Set target Android
buildPlayerOptions.target = BuildTarget.Android;
// Get all scenes paths that are added to build settings
buildPlayerOptions.scenes = EditorBuildSettings.scenes.Select(scene => scene.path).ToArray();
// Set Graphics API
switch ((int)(buildQueueItem.BuildOptions as AndroidBuildOptions).GraphicsAPI)
{
case (int)CustomAndroidGraphicsAPI.OpenGLES3:
PlayerSettings.SetGraphicsAPIs(BuildTarget.Android, new[] { GraphicsDeviceType.OpenGLES3 });
break;
case (int)CustomAndroidGraphicsAPI.Vulkan:
PlayerSettings.SetGraphicsAPIs(BuildTarget.Android, new[] { GraphicsDeviceType.Vulkan });
break;
default:
throw new Exception("Unknown Graphics API selected");
}
// Set Scripting backend
switch ((int)(buildQueueItem.BuildOptions as AndroidBuildOptions).ScriptingBackend)
{
case (int)CustomAndroidScriptingBackend.Mono:
PlayerSettings.SetScriptingBackend(BuildTargetGroup.Android, ScriptingImplementation.Mono2x);
break;
case (int)CustomAndroidScriptingBackend.IL2CPP:
PlayerSettings.SetScriptingBackend(BuildTargetGroup.Android, ScriptingImplementation.IL2CPP);
break;
default:
throw new Exception("Unknown scripting backend selected");
}
// Set installation path
buildPlayerOptions.locationPathName = "Builds/" +
Application.productName + "_" +
PlayerSettings.GetScriptingBackend(BuildTargetGroup.Android) + "_" +
PlayerSettings.GetGraphicsAPIs(BuildTarget.Android)[0] +
".apk";
// Build player
BuildReport report = BuildPipeline.BuildPlayer(buildPlayerOptions);
BuildSummary summary = report.summary;
if (summary.result == BuildResult.Succeeded)
{
Debug.Log("Build succeeded: " + summary.totalSize + " bytes\nBuild location: " + buildPlayerOptions.locationPathName);
}
if (summary.result == BuildResult.Failed)
{
throw new Exception("Build failed");
}
}
public void OnPreprocessBuild(BuildReport report)
{
// Always remember to cleanup preloaded assets after build to make sure we don't
// dirty later builds with assets that may not be needed or are out of date.
CleanOldSettings();
XRGeneralSettingsPerBuildTarget buildTargetSettings = null;
EditorBuildSettings.TryGetConfigObject(XRGeneralSettings.k_SettingsKey, out buildTargetSettings);
if (buildTargetSettings == null)
{
return;
}
XRGeneralSettings settings = buildTargetSettings.SettingsForBuildTarget(report.summary.platformGroup);
if (settings == null)
{
return;
}
// store off some info about the first loader in the list for PreInit boot.config purposes
preInitInfo = null;
XRManagerSettings loaderManager = settings.AssignedSettings;
if (loaderManager != null)
{
List <XRLoader> loaders = loaderManager.loaders;
if (loaders.Count >= 1)
{
preInitInfo = new PreInitInfo(loaders[0] as IXRLoaderPreInit, report.summary.platform, report.summary.platformGroup);
}
}
if (loaderManager != null)
{
// chances are that our devices won't fall back to graphics device types later in the list so it's better to assume the device will be created with the first gfx api in the list.
// furthermore, we have no way to influence falling back to other graphics API types unless we automatically change settings underneath the user which is no good!
GraphicsDeviceType[] deviceTypes = PlayerSettings.GetGraphicsAPIs(report.summary.platform);
if (deviceTypes.Length > 0)
{
VerifyGraphicsAPICompatibility(loaderManager, deviceTypes[0]);
}
else
{
Debug.LogWarning("No Graphics APIs have been configured in Player Settings.");
}
}
UnityEngine.Object[] preloadedAssets = PlayerSettings.GetPreloadedAssets();
if (!preloadedAssets.Contains(settings))
{
var assets = preloadedAssets.ToList();
assets.Add(settings);
PlayerSettings.SetPreloadedAssets(assets.ToArray());
}
}
public bool PlayerSettingsGraphicsAPIs_iOS_OpenGLESAndMetal()
{
var graphicsAPIs = PlayerSettings.GetGraphicsAPIs(BuildTarget.iOS);
var hasOpenGLES = graphicsAPIs.Contains(GraphicsDeviceType.OpenGLES2) ||
graphicsAPIs.Contains(GraphicsDeviceType.OpenGLES3);
return(graphicsAPIs.Contains(GraphicsDeviceType.Metal) && hasOpenGLES);
}
private void CheckOpenGLEnabledForStandaloneBuilds()
{
#if (UNITY_4_0 || UNITY_4_1 || UNITY_4_2 || UNITY_4_3 || UNITY_4_4 || UNITY_4_5 || UNITY_4_6 || UNITY_4_7)
return;
#else
UnityEngine.Rendering.GraphicsDeviceType[] graphicsAPIs = null;
bool isOpenGLEnabledWin32 = false;
bool isOpenGLEnabledWin64 = false;
// Check if OpenGL2 is enabled for Win32 standalone builds:
graphicsAPIs = PlayerSettings.GetGraphicsAPIs(BuildTarget.StandaloneWindows);
foreach (var g in graphicsAPIs)
{
if (g == UnityEngine.Rendering.GraphicsDeviceType.OpenGL2)
{
isOpenGLEnabledWin32 = true;
}
}
// Check if OpenGL2 is enabled for Win64 standalone builds:
graphicsAPIs = PlayerSettings.GetGraphicsAPIs(BuildTarget.StandaloneWindows64);
foreach (var g in graphicsAPIs)
{
if (g == UnityEngine.Rendering.GraphicsDeviceType.OpenGL2)
{
isOpenGLEnabledWin64 = true;
}
}
// If OpenGL2 is not enabled, display a warning for the user with instructions
// on how to enable it.
if (!isOpenGLEnabledWin32 || !isOpenGLEnabledWin64)
{
string unsupportedBuildTargets = string.Empty;
if (!isOpenGLEnabledWin32)
{
unsupportedBuildTargets += "\nStandaloneWindows (x86)";
}
if (!isOpenGLEnabledWin64)
{
unsupportedBuildTargets += "\nStandaloneWindows64 (x86_64)";
}
EditorGUILayout.HelpBox(
"zSpace has detected that OpenGL2 rendering support is currently disabled for the following " +
"standalone player build targets:\n" + unsupportedBuildTargets + "\n\n" +
"As a result, standalone player builds will be unable to support OpenGL stereoscopic 3D rendering. " +
"To enable OpenGL stereoscopic 3D rendering support, go to:\n\n" +
"Edit > Project Settings > Player > PC, Mac & Linux Standalone > Other Settings\n\n" +
"Uncheck \"Auto Graphics API for Windows\" " +
"and manually add OpenGL2 to the list of graphics APIs for Windows.",
MessageType.Warning);
EditorGUILayout.Space();
}
#endif
}
private static void AddGraphicApi(BuildTarget target, UnityEngine.Rendering.GraphicsDeviceType type)
{
List <UnityEngine.Rendering.GraphicsDeviceType> deviceTypes = PlayerSettings.GetGraphicsAPIs(BuildTarget.StandaloneWindows).ToList <UnityEngine.Rendering.GraphicsDeviceType>();
if (!deviceTypes.Contains(type))
{
deviceTypes.Add(type);
PlayerSettings.SetGraphicsAPIs(target, deviceTypes.ToArray());
}
}
private void WarnOnGraphicsAPIIncompatibility(BuildTargetGroup targetGroup)
{
if (targetGroup == BuildTargetGroup.Android && PlayerSettings.GetGraphicsAPIs(BuildTarget.Android).Contains(UnityEngine.Rendering.GraphicsDeviceType.Vulkan))
{
if (PlayerSettings.Android.ARCoreEnabled || PlayerSettings.GetPlatformVuforiaEnabled(targetGroup) || PlayerSettings.virtualRealitySupported)
{
EditorGUILayout.HelpBox("XR is currently not supported when using the Vulkan Graphics API.\nPlease go to 'Other Settings' and remove 'Vulkan' from the list of Graphics APIs.", MessageType.Warning);
}
}
}
private static int GetGraphicsAPIsMaskForPlatform(BuildTarget varBuildTarget)
{
var tempMask = 0;
var tempAPIs = PlayerSettings.GetGraphicsAPIs(varBuildTarget);
for (int i = 0; i < tempAPIs.Length; ++i)
{
tempMask |= (1 << (int)tempAPIs[i]);
}
return(tempMask);
}
private void ValidateGraphicsApis()
{
BuildTarget platform = EditorUserBuildSettings.activeBuildTarget;
GraphicsDeviceType[] graphicsAPIs = PlayerSettings.GetGraphicsAPIs(platform);
if (System.Array.FindIndex(graphicsAPIs, element => element == GraphicsDeviceType.OpenGLES2) >= 0)
{
EditorGUILayout.HelpBox("Decals are not supported with OpenGLES2.", MessageType.Warning);
}
}
public void OnPreprocessBuild(BuildReport report)
{
if (!PlayerSettings.GetUseDefaultGraphicsAPIs(BuildTarget.Android))
{
GraphicsDeviceType[] apis = PlayerSettings.GetGraphicsAPIs(BuildTarget.Android);
if (apis.Length >= 1 && apis[0] == GraphicsDeviceType.Vulkan)
{
throw new BuildFailedException("XR is currently not supported when using the Vulkan Graphics API. Please go to PlayerSettings and remove 'Vulkan' from the list of Graphics APIs.");
}
}
}
#pragma warning restore 649
static Hash128 GetPlayerSettingsHash128(BuildTarget target)
{
return(HashingMethods.Calculate(
PlayerSettings.stripUnusedMeshComponents,
PlayerSettings.bakeCollisionMeshes
#if UNITY_2020_1_OR_NEWER
, PlayerSettings.mipStripping ? PlayerSettingsApi.GetNumberOfMipsStripped() : 0
#endif
, PlayerSettings.GetGraphicsAPIs(target)
).ToHash128());
}
/// <summary>
/// 預設IOS資料(取現在的PlayerSetting)
/// </summary>
private void DefaultSetIOS()
{
SDIOSSet aTmpSet = new SDIOSSet();
// Resolution and Presentation
aTmpSet.RequiresFullScreen = PlayerSettings.iOS.requiresFullScreen;
aTmpSet.StatusBarHidden = PlayerSettings.statusBarHidden;
aTmpSet.StatusBarStyle = PlayerSettings.iOS.statusBarStyle;
aTmpSet.ShowActivityIndicatorOnLoading = PlayerSettings.iOS.showActivityIndicatorOnLoading;
// Debugging and crash reporting
aTmpSet.ActionOnDotNetUnhandledException = PlayerSettings.actionOnDotNetUnhandledException;
aTmpSet.LogObjCUncaughtExceptions = PlayerSettings.logObjCUncaughtExceptions;
aTmpSet.EnableCrashReportAPI = PlayerSettings.enableCrashReportAPI;
// Identification
aTmpSet.BundleIDIOS = PlayerSettings.GetApplicationIdentifier(BuildTargetGroup.iOS);
aTmpSet.BuildNumber = PlayerSettings.iOS.buildNumber;
aTmpSet.AppleEnableAutomaticSigning = PlayerSettings.iOS.appleEnableAutomaticSigning;
aTmpSet.AppleDeveloperTeamID = PlayerSettings.iOS.appleDeveloperTeamID;
aTmpSet.ProvisioningProfileID = PlayerSettings.iOS.iOSManualProvisioningProfileID;
// Configuration
aTmpSet.ScriptingBackend = PlayerSettings.GetScriptingBackend(BuildTargetGroup.iOS);
aTmpSet.ApiCompatibilityLevel = PlayerSettings.GetApiCompatibilityLevel(BuildTargetGroup.iOS);
aTmpSet.TargetDevice = PlayerSettings.iOS.targetDevice;
aTmpSet.SDKVersion = PlayerSettings.iOS.sdkVersion;
aTmpSet.TargetOSVersionString = PlayerSettings.iOS.targetOSVersionString;
aTmpSet.PrepareIOSForRecording = SDDataMove.GetBoolPlayerSetting("Prepare IOS For Recording");
aTmpSet.RequiresPersistentWiFi = PlayerSettings.iOS.requiresPersistentWiFi;
aTmpSet.AppInBackgroundBehavior = PlayerSettings.iOS.appInBackgroundBehavior;
aTmpSet.Architecture = PlayerSettings.GetArchitecture(BuildTargetGroup.iOS);
// Optimization
aTmpSet.ScriptCallOptimizationLevel = PlayerSettings.iOS.scriptCallOptimization;
aTmpSet.StripEngineCode = PlayerSettings.stripEngineCode;
aTmpSet.StripLevel = PlayerSettings.strippingLevel;
// Scripting Define Symbols
aTmpSet.ScriptDefineSymblos = PlayerSettings.GetScriptingDefineSymbolsForGroup(BuildTargetGroup.iOS);
// Icon
aTmpSet.IconOverride = true;
SDDataMove.GetIconsGroup(BuildTargetGroup.iOS, ref mUIUseImages.IosIcons, ref aTmpSet.DefIcons);
aTmpSet.PrerenderedIcon = PlayerSettings.iOS.prerenderedIcon;
// Splash Images
int aEmumTotal = Enum.GetNames(typeof(eMobileSplashScreen)).Length;
mUIUseImages.IOSSplashImages = new Texture2D[aEmumTotal];
aTmpSet.SplashImages = new string[aEmumTotal];
for (int i = 0; i < aEmumTotal; i++)
{
aTmpSet.SplashImages[i] = SDDataMove.GetSplashScreenPath((eMobileSplashScreen)i, ref mUIUseImages.IOSSplashImages[i]);
}
//-------------------------------------------------
// Unity5 New
aTmpSet.GraphicsType = PlayerSettings.GetGraphicsAPIs(BuildTarget.iOS);
// Set Down
mShowSetInfo.IOSSet = aTmpSet;
}
void EnsureOpenGLIsUsed()
{
var graphicsApis = PlayerSettings.GetGraphicsAPIs(BuildTarget.iOS);
if (graphicsApis.Length > 0)
{
if (!graphicsApis.Contains(GraphicsDeviceType.OpenGLES2))
{
throw new BuildFailedException("To build for 'Universal' architecture, OpenGLES2 is needed. (See Player Settings > Other Settings > Graphics APIs)");
}
}
}
internal void SinglePassStereoGUI(BuildTargetGroup targetGroup, SerializedProperty stereoRenderingPath)
{
if (PlayerSettings.virtualRealitySupported)
{
bool flag = PlayerSettingsEditorVR.TargetSupportsSinglePassStereoRendering(targetGroup);
bool flag2 = PlayerSettingsEditorVR.TargetSupportsStereoInstancingRendering(targetGroup);
int num = 1 + ((!flag) ? 0 : 1) + ((!flag2) ? 0 : 1);
GUIContent[] array = new GUIContent[num];
int[] array2 = new int[num];
int[] array3 = new int[]
{
0,
1,
2
};
GUIContent[] stereoRenderingPaths = PlayerSettingsEditorVR.GetStereoRenderingPaths(targetGroup);
int num2 = 0;
array[num2] = stereoRenderingPaths[0];
array2[num2++] = array3[0];
if (flag)
{
array[num2] = stereoRenderingPaths[1];
array2[num2++] = array3[1];
}
if (flag2 && stereoRenderingPaths.Length > 2)
{
array[num2] = stereoRenderingPaths[2];
array2[num2++] = array3[2];
}
if (!flag2 && stereoRenderingPath.intValue == 2)
{
stereoRenderingPath.intValue = 1;
}
if (!flag && stereoRenderingPath.intValue == 1)
{
stereoRenderingPath.intValue = 0;
}
EditorGUILayout.IntPopup(stereoRenderingPath, array, array2, EditorGUIUtility.TextContent("Stereo Rendering Method*"), new GUILayoutOption[0]);
if (stereoRenderingPath.intValue == 1 && targetGroup == BuildTargetGroup.Android)
{
GraphicsDeviceType[] graphicsAPIs = PlayerSettings.GetGraphicsAPIs(BuildTarget.Android);
if (graphicsAPIs.Length > 0 && graphicsAPIs[0] == GraphicsDeviceType.OpenGLES3)
{
EditorGUILayout.HelpBox(PlayerSettingsEditorVR.Styles.singlepassAndroidWarning2.text, MessageType.Warning);
}
else
{
EditorGUILayout.HelpBox(PlayerSettingsEditorVR.Styles.singlepassAndroidWarning.text, MessageType.Error);
}
}
}
}
public void OnPreprocessBuild(BuildReport report)
{
#if UNITY_ANDROID && !(USING_XR_SDK && UNITY_2019_3_OR_NEWER)
// Generate error when Vulkan is selected as the perferred graphics API, which is not currently supported in Unity XR
if (!PlayerSettings.GetUseDefaultGraphicsAPIs(BuildTarget.Android))
{
GraphicsDeviceType[] apis = PlayerSettings.GetGraphicsAPIs(BuildTarget.Android);
if (apis.Length >= 1 && apis[0] == GraphicsDeviceType.Vulkan)
{
throw new BuildFailedException("The Vulkan Graphics API does not support XR in your configuration. To use Vulkan, you must use Unity 2019.3 or newer, and the XR Plugin Management.");
}
}
#endif
#if UNITY_ANDROID
bool useOpenXR = OVRPluginUpdater.IsOVRPluginOpenXRActivated();
#if USING_XR_SDK
if (useOpenXR)
{
UnityEngine.Debug.LogWarning("Oculus Utilities Plugin with OpenXR is being used, which is under experimental status");
if (PlayerSettings.colorSpace != ColorSpace.Linear)
{
throw new BuildFailedException("Oculus Utilities Plugin with OpenXR only supports linear lighting. Please set 'Rendering/Color Space' to 'Linear' in Player Settings");
}
}
#else
if (useOpenXR)
{
throw new BuildFailedException("Oculus Utilities Plugin with OpenXR only supports XR Plug-in Managmenent with Oculus XR Plugin.");
}
#endif
#endif
#if UNITY_ANDROID && USING_XR_SDK && !USING_COMPATIBLE_OCULUS_XR_PLUGIN_VERSION
if (PlayerSettings.Android.targetArchitectures != AndroidArchitecture.ARM64)
{
throw new BuildFailedException("Your project is using an Oculus XR Plugin version with known issues. Please navigate to the Package Manager and upgrade the Oculus XR Plugin to the latest verified version. When performing the upgrade" +
", you must first \"Remove\" the Oculus XR Plugin package, and then \"Install\" the package at the verified version. Be sure to remove, then install, not just upgrade.");
}
#endif
buildStartTime = System.DateTime.Now;
buildGuid = System.Guid.NewGuid();
#if BUILDSESSION
StreamWriter writer = new StreamWriter("build_session", false);
UnityEngine.Debug.LogFormat("Build Session: {0}", buildGuid.ToString());
writer.WriteLine(buildGuid.ToString());
writer.Close();
#endif
}
