369 lines
16 KiB
C#
369 lines
16 KiB
C#
/*
|
|
* Copyright (c) Meta Platforms, Inc. and affiliates.
|
|
* All rights reserved.
|
|
*
|
|
* Licensed under the Oculus SDK License Agreement (the "License");
|
|
* you may not use the Oculus SDK except in compliance with the License,
|
|
* which is provided at the time of installation or download, or which
|
|
* otherwise accompanies this software in either electronic or hard copy form.
|
|
*
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* https://developer.oculus.com/licenses/oculussdk/
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, the Oculus SDK
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
using System;
|
|
using System.Linq;
|
|
using UnityEditor;
|
|
using UnityEditor.Rendering;
|
|
using UnityEngine;
|
|
using UnityEngine.Rendering;
|
|
#if USING_URP
|
|
using UnityEngine.Rendering.Universal;
|
|
#endif
|
|
|
|
|
|
[InitializeOnLoad]
|
|
internal static class OVRProjectSetupRenderingTasks
|
|
{
|
|
#if USING_XR_SDK_OCULUS
|
|
private static Unity.XR.Oculus.OculusSettings OculusSettings
|
|
{
|
|
get
|
|
{
|
|
UnityEditor.EditorBuildSettings.TryGetConfigObject<Unity.XR.Oculus.OculusSettings>(
|
|
"Unity.XR.Oculus.Settings", out var settings);
|
|
return settings;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#if USING_URP && UNITY_2022_2_OR_NEWER
|
|
// Call action for all UniversalRendererData being used, return true if all the return value of action is true
|
|
private static bool ForEachRendererData(Func<UniversalRendererData, bool> action)
|
|
{
|
|
var ret = true;
|
|
var pipelineAssets = new System.Collections.Generic.List<RenderPipelineAsset>();
|
|
QualitySettings.GetAllRenderPipelineAssetsForPlatform("Android", ref pipelineAssets);
|
|
foreach (var pipelineAsset in pipelineAssets)
|
|
{
|
|
var urpPipelineAsset = pipelineAsset as UniversalRenderPipelineAsset;
|
|
// If using URP pipeline
|
|
if (urpPipelineAsset)
|
|
{
|
|
var path = AssetDatabase.GetAssetPath(urpPipelineAsset);
|
|
var dependency = AssetDatabase.GetDependencies(path);
|
|
for (int i = 0; i < dependency.Length; i++)
|
|
{
|
|
// Try to read the dependency as UniversalRendererData
|
|
if (AssetDatabase.GetMainAssetTypeAtPath(dependency[i]) != typeof(UniversalRendererData))
|
|
continue;
|
|
|
|
UniversalRendererData renderData =
|
|
(UniversalRendererData)AssetDatabase.LoadAssetAtPath(dependency[i],
|
|
typeof(UniversalRendererData));
|
|
if (renderData)
|
|
{
|
|
ret = ret && action(renderData);
|
|
}
|
|
|
|
if (!ret)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
#endif
|
|
|
|
private static GraphicsDeviceType[] GetGraphicsAPIs(BuildTargetGroup buildTargetGroup)
|
|
{
|
|
var buildTarget = buildTargetGroup.GetBuildTarget();
|
|
if (PlayerSettings.GetUseDefaultGraphicsAPIs(buildTarget))
|
|
{
|
|
return Array.Empty<GraphicsDeviceType>();
|
|
}
|
|
|
|
// Recommends OpenGL ES 3 or Vulkan
|
|
return PlayerSettings.GetGraphicsAPIs(buildTarget);
|
|
}
|
|
|
|
static OVRProjectSetupRenderingTasks()
|
|
{
|
|
const OVRProjectSetup.TaskGroup targetGroup = OVRProjectSetup.TaskGroup.Rendering;
|
|
|
|
//[Required] Set the color space to linear
|
|
OVRProjectSetup.AddTask(
|
|
conditionalLevel: buildTargetGroup =>
|
|
OVRProjectSetupUtils.IsPackageInstalled(OVRProjectSetupXRTasks.UnityXRPackage)
|
|
? OVRProjectSetup.TaskLevel.Required
|
|
: OVRProjectSetup.TaskLevel.Recommended,
|
|
group: targetGroup,
|
|
isDone: buildTargetGroup => PlayerSettings.colorSpace == ColorSpace.Linear,
|
|
message: "Color Space is required to be Linear",
|
|
fix: buildTargetGroup => PlayerSettings.colorSpace = ColorSpace.Linear,
|
|
fixMessage: "PlayerSettings.colorSpace = ColorSpace.Linear"
|
|
);
|
|
|
|
|
|
#if USING_XR_SDK_OCULUS && OCULUS_XR_EYE_TRACKED_FOVEATED_RENDERING && UNITY_2021_3_OR_NEWER
|
|
//[Required] Use Vulkan and IL2CPP/ARM64 when using ETFR
|
|
OVRProjectSetup.AddTask(
|
|
level: OVRProjectSetup.TaskLevel.Required,
|
|
group: targetGroup,
|
|
isDone: buildTargetGroup =>
|
|
{
|
|
var useIL2CPP = PlayerSettings.GetScriptingBackend(buildTargetGroup) == ScriptingImplementation.IL2CPP;
|
|
var useARM64 = PlayerSettings.Android.targetArchitectures == AndroidArchitecture.ARM64;
|
|
var useVK = GetGraphicsAPIs(buildTargetGroup).Any(item => item == GraphicsDeviceType.Vulkan);
|
|
return useVK && useARM64 && useIL2CPP;
|
|
},
|
|
message: "Need to use Vulkan for Graphics APIs, IL2CPP for scripting backend, and ARM64 for target architectures when using eye-tracked foveated rendering",
|
|
fix: buildTargetGroup =>
|
|
{
|
|
var buildTarget = buildTargetGroup.GetBuildTarget();
|
|
PlayerSettings.Android.targetArchitectures = AndroidArchitecture.ARM64;
|
|
PlayerSettings.SetScriptingBackend(buildTargetGroup, ScriptingImplementation.IL2CPP);
|
|
PlayerSettings.SetGraphicsAPIs(buildTarget, new[] { GraphicsDeviceType.Vulkan });
|
|
},
|
|
fixMessage: "Set target architectures to ARM64, scripting backend to IL2CPP, and Graphics APIs to Vulkan for this build.",
|
|
conditionalValidity: buildTargetGroup => OculusSettings?.FoveatedRenderingMethod == Unity.XR.Oculus.OculusSettings.FoveationMethod.EyeTrackedFoveatedRendering
|
|
);
|
|
#endif
|
|
|
|
//[Required] Disable Graphics Jobs
|
|
OVRProjectSetup.AddTask(
|
|
level: OVRProjectSetup.TaskLevel.Recommended,
|
|
group: targetGroup,
|
|
isDone: buildTargetGroup => !PlayerSettings.graphicsJobs,
|
|
message: "Disable Graphics Jobs",
|
|
fix: buildTargetGroup => PlayerSettings.graphicsJobs = false,
|
|
fixMessage: "PlayerSettings.graphicsJobs = false"
|
|
);
|
|
|
|
//[Recommended] Set the Graphics API order for Android
|
|
OVRProjectSetup.AddTask(
|
|
level: OVRProjectSetup.TaskLevel.Recommended,
|
|
platform: BuildTargetGroup.Android,
|
|
group: targetGroup,
|
|
isDone: buildTargetGroup =>
|
|
GetGraphicsAPIs(buildTargetGroup).Any(item =>
|
|
item == GraphicsDeviceType.OpenGLES3 || item == GraphicsDeviceType.Vulkan),
|
|
message: "Manual selection of Graphic API, favoring Vulkan (or OpenGLES3)",
|
|
fix: buildTargetGroup =>
|
|
{
|
|
var buildTarget = buildTargetGroup.GetBuildTarget();
|
|
PlayerSettings.SetUseDefaultGraphicsAPIs(buildTarget, false);
|
|
PlayerSettings.SetGraphicsAPIs(buildTarget, new[] { GraphicsDeviceType.Vulkan });
|
|
},
|
|
fixMessage: "Set Graphics APIs for this build target to Vulkan"
|
|
);
|
|
//[Required] Set the Graphics API order for Windows
|
|
OVRProjectSetup.AddTask(
|
|
level: OVRProjectSetup.TaskLevel.Required,
|
|
platform: BuildTargetGroup.Standalone,
|
|
group: targetGroup,
|
|
isDone: buildTargetGroup =>
|
|
GetGraphicsAPIs(buildTargetGroup).Any(item =>
|
|
item == GraphicsDeviceType.Direct3D11),
|
|
message: "Manual selection of Graphic API, favoring Direct3D11",
|
|
fix: buildTargetGroup =>
|
|
{
|
|
var buildTarget = buildTargetGroup.GetBuildTarget();
|
|
PlayerSettings.SetUseDefaultGraphicsAPIs(buildTarget, false);
|
|
PlayerSettings.SetGraphicsAPIs(buildTarget, new[] { GraphicsDeviceType.Direct3D11 });
|
|
},
|
|
fixMessage: "Set Graphics APIs for this build target to Direct3D11"
|
|
);
|
|
|
|
//[Recommended] Enable Multithreaded Rendering
|
|
OVRProjectSetup.AddTask(
|
|
level: OVRProjectSetup.TaskLevel.Recommended,
|
|
group: targetGroup,
|
|
isDone: buildTargetGroup => PlayerSettings.MTRendering &&
|
|
(buildTargetGroup != BuildTargetGroup.Android
|
|
|| PlayerSettings.GetMobileMTRendering(buildTargetGroup)),
|
|
message: "Enable Multithreaded Rendering",
|
|
fix: buildTargetGroup =>
|
|
{
|
|
PlayerSettings.MTRendering = true;
|
|
if (buildTargetGroup == BuildTargetGroup.Android)
|
|
{
|
|
PlayerSettings.SetMobileMTRendering(buildTargetGroup, true);
|
|
}
|
|
},
|
|
conditionalFixMessage: buildTargetGroup =>
|
|
buildTargetGroup == BuildTargetGroup.Android
|
|
? "PlayerSettings.MTRendering = true and PlayerSettings.SetMobileMTRendering(buildTargetGroup, true)"
|
|
: "PlayerSettings.MTRendering = true"
|
|
);
|
|
|
|
#if USING_XR_SDK_OCULUS
|
|
//[Recommended] Select Low Overhead Mode
|
|
OVRProjectSetup.AddTask(
|
|
level: OVRProjectSetup.TaskLevel.Recommended,
|
|
conditionalValidity: buildTargetGroup =>
|
|
GetGraphicsAPIs(buildTargetGroup).Contains(GraphicsDeviceType.OpenGLES3),
|
|
group: targetGroup,
|
|
platform: BuildTargetGroup.Android,
|
|
isDone: buildTargetGroup => OculusSettings?.LowOverheadMode ?? true,
|
|
message: "Use Low Overhead Mode",
|
|
fix: buildTargetGroup =>
|
|
{
|
|
var setting = OculusSettings;
|
|
if (setting != null)
|
|
{
|
|
setting.LowOverheadMode = true;
|
|
EditorUtility.SetDirty(setting);
|
|
}
|
|
},
|
|
fixMessage: "OculusSettings.LowOverheadMode = true"
|
|
);
|
|
|
|
//[Recommended] Enable Dash Support
|
|
OVRProjectSetup.AddTask(
|
|
level: OVRProjectSetup.TaskLevel.Recommended,
|
|
group: targetGroup,
|
|
platform: BuildTargetGroup.Standalone,
|
|
isDone: buildTargetGroup => OculusSettings?.DashSupport ?? true,
|
|
message: "Enable Dash Support",
|
|
fix: buildTargetGroup =>
|
|
{
|
|
var setting = OculusSettings;
|
|
if (setting != null)
|
|
{
|
|
setting.DashSupport = true;
|
|
EditorUtility.SetDirty(setting);
|
|
}
|
|
},
|
|
fixMessage: "OculusSettings.DashSupport = true"
|
|
);
|
|
#endif
|
|
|
|
//[Recommended] Set the Display Buffer Format to 32 bit
|
|
OVRProjectSetup.AddTask(
|
|
level: OVRProjectSetup.TaskLevel.Recommended,
|
|
group: targetGroup,
|
|
isDone: buildTargetGroup =>
|
|
PlayerSettings.use32BitDisplayBuffer,
|
|
message: "Use 32Bit Display Buffer",
|
|
fix: buildTargetGroup => PlayerSettings.use32BitDisplayBuffer = true,
|
|
fixMessage: "PlayerSettings.use32BitDisplayBuffer = true"
|
|
);
|
|
|
|
//[Recommended] Set the Rendering Path to Forward
|
|
// TODO : Support Scripted Rendering Pipeline?
|
|
OVRProjectSetup.AddTask(
|
|
level: OVRProjectSetup.TaskLevel.Recommended,
|
|
group: targetGroup,
|
|
isDone: buildTargetGroup =>
|
|
EditorGraphicsSettings.GetTierSettings(buildTargetGroup, Graphics.activeTier).renderingPath ==
|
|
RenderingPath.Forward,
|
|
message: "Use Forward Rendering Path",
|
|
fix: buildTargetGroup =>
|
|
{
|
|
var renderingTier = EditorGraphicsSettings.GetTierSettings(buildTargetGroup, Graphics.activeTier);
|
|
renderingTier.renderingPath =
|
|
RenderingPath.Forward;
|
|
EditorGraphicsSettings.SetTierSettings(buildTargetGroup, Graphics.activeTier, renderingTier);
|
|
},
|
|
fixMessage: "renderingTier.renderingPath = RenderingPath.Forward"
|
|
);
|
|
|
|
//[Recommended] Set the Stereo Rendering to Instancing
|
|
OVRProjectSetup.AddTask(
|
|
level: OVRProjectSetup.TaskLevel.Recommended,
|
|
group: targetGroup,
|
|
isDone: buildTargetGroup =>
|
|
PlayerSettings.stereoRenderingPath == StereoRenderingPath.Instancing,
|
|
message: "Use Stereo Rendering Instancing",
|
|
fix: buildTargetGroup => PlayerSettings.stereoRenderingPath = StereoRenderingPath.Instancing,
|
|
fixMessage: "PlayerSettings.stereoRenderingPath = StereoRenderingPath.Instancing"
|
|
);
|
|
|
|
#if USING_URP && UNITY_2022_2_OR_NEWER
|
|
//[Recommended] When using URP, set Intermediate texture to "Auto"
|
|
OVRProjectSetup.AddTask(
|
|
level: OVRProjectSetup.TaskLevel.Recommended,
|
|
group: targetGroup,
|
|
isDone: buildTargetGroup =>
|
|
ForEachRendererData(rd => { return rd.intermediateTextureMode == IntermediateTextureMode.Auto; }),
|
|
message: "Setting the intermate texture mode to \"Always\" might have a performance impact, it is recommended to use \"Auto\"",
|
|
fix: buildTargetGroup =>
|
|
ForEachRendererData(rd => { rd.intermediateTextureMode = IntermediateTextureMode.Auto; return true; }),
|
|
fixMessage: "Set Intermediate texture to \"Auto\""
|
|
);
|
|
|
|
//[Recommended] When using URP, disable SSAO
|
|
OVRProjectSetup.AddTask(
|
|
level: OVRProjectSetup.TaskLevel.Recommended,
|
|
group: targetGroup,
|
|
isDone: buildTargetGroup =>
|
|
ForEachRendererData(rd =>
|
|
{
|
|
return rd.rendererFeatures.Count == 0
|
|
|| !rd.rendererFeatures.Any(
|
|
feature => feature != null && (feature.isActive && feature.GetType().Name == "ScreenSpaceAmbientOcclusion"));
|
|
}),
|
|
message: "SSAO will have some performace impact, it is recommended to disable SSAO",
|
|
fix: buildTargetGroup =>
|
|
ForEachRendererData(rd =>
|
|
{
|
|
rd.rendererFeatures.ForEach(feature =>
|
|
{
|
|
if (feature != null && feature.GetType().Name == "ScreenSpaceAmbientOcclusion")
|
|
feature.SetActive(false);
|
|
}
|
|
);
|
|
return true;
|
|
}),
|
|
fixMessage: "Disable SSAO"
|
|
);
|
|
#endif
|
|
|
|
//[Optional] Use Non-Directional Lightmaps
|
|
OVRProjectSetup.AddTask(
|
|
level: OVRProjectSetup.TaskLevel.Optional,
|
|
group: targetGroup,
|
|
isDone: buildTargetGroup =>
|
|
{
|
|
return LightmapSettings.lightmaps.Length == 0 ||
|
|
LightmapSettings.lightmapsMode == LightmapsMode.NonDirectional;
|
|
},
|
|
message: "Use Non-Directional lightmaps",
|
|
fix: buildTargetGroup => LightmapSettings.lightmapsMode = LightmapsMode.NonDirectional,
|
|
fixMessage: "LightmapSettings.lightmapsMode = LightmapsMode.NonDirectional"
|
|
);
|
|
|
|
//[Optional] Disable Realtime GI
|
|
OVRProjectSetup.AddTask(
|
|
level: OVRProjectSetup.TaskLevel.Optional,
|
|
group: targetGroup,
|
|
isDone: buildTargetGroup => !Lightmapping.realtimeGI,
|
|
message: "Disable Realtime Global Illumination",
|
|
fix: buildTargetGroup => Lightmapping.realtimeGI = false,
|
|
fixMessage: "Lightmapping.realtimeGI = false"
|
|
);
|
|
|
|
//[Optional] GPU Skinning
|
|
OVRProjectSetup.AddTask(
|
|
level: OVRProjectSetup.TaskLevel.Optional,
|
|
platform: BuildTargetGroup.Android,
|
|
group: targetGroup,
|
|
isDone: buildTargetGroup => PlayerSettings.gpuSkinning,
|
|
message: "Consider using GPU Skinning if your application is CPU bound",
|
|
fix: buildTargetGroup => PlayerSettings.gpuSkinning = true,
|
|
fixMessage: "PlayerSettings.gpuSkinning = true"
|
|
);
|
|
}
|
|
}
|