public static void SetShaderSettingsForPlatform(BuildTargetGroup target, ShaderHardwareTier tier, PlatformShaderSettings settings)
        {
            TierSettings tierSettings = EditorGraphicsSettings.GetTierSettings(target, (GraphicsTier)tier);

            tierSettings.standardShaderQuality        = settings.standardShaderQuality;
            tierSettings.cascadedShadowMaps           = settings.cascadedShadowMaps;
            tierSettings.reflectionProbeBoxProjection = settings.reflectionProbeBoxProjection;
            tierSettings.reflectionProbeBlending      = settings.reflectionProbeBlending;
            EditorGraphicsSettings.SetTierSettings(target, (GraphicsTier)tier, tierSettings);
        }
        public static PlatformShaderSettings GetShaderSettingsForPlatform(BuildTargetGroup target, ShaderHardwareTier tier)
        {
            TierSettings tierSettings = GetTierSettings(target, (GraphicsTier)tier);

            return(new PlatformShaderSettings {
                cascadedShadowMaps = tierSettings.cascadedShadowMaps,
                standardShaderQuality = tierSettings.standardShaderQuality,
                reflectionProbeBoxProjection = tierSettings.reflectionProbeBoxProjection,
                reflectionProbeBlending = tierSettings.reflectionProbeBlending
            });
        }
        public static void SetShaderSettingsForPlatform(BuildTargetGroup target, ShaderHardwareTier tier, PlatformShaderSettings settings)
        {
            TierSettings settings2 = new TierSettings {
                standardShaderQuality        = settings.standardShaderQuality,
                cascadedShadowMaps           = settings.cascadedShadowMaps,
                reflectionProbeBoxProjection = settings.reflectionProbeBoxProjection,
                reflectionProbeBlending      = settings.reflectionProbeBlending
            };

            SetTierSettings(target, (GraphicsTier)tier, settings2);
        }
 private static extern void INTERNAL_CALL_GetTierSettingsImpl(BuildTargetGroup target, GraphicsTier tier, out TierSettings value);
 private static extern void INTERNAL_CALL_GetCurrentTierSettingsImpl(out TierSettings value);
 internal static void SetTierSettingsImpl(BuildTargetGroup target, GraphicsTier tier, TierSettings settings)
 {
     EditorGraphicsSettings.INTERNAL_CALL_SetTierSettingsImpl(target, tier, ref settings);
 }
 private static extern void INTERNAL_CALL_SetTierSettingsImpl(BuildTargetGroup target, GraphicsTier tier, ref TierSettings settings);
 private static extern void INTERNAL_CALL_GetCurrentTierSettingsImpl(out TierSettings value);
 public static void SetTierSettings(BuildTargetGroup target, ShaderHardwareTier tier, TierSettings settings)
 {
     EditorGraphicsSettings.SetTierSettings(target, (GraphicsTier)tier, settings);
 }
 internal static void SetTierSettingsImpl(BuildTargetGroup target, GraphicsTier tier, TierSettings settings)
 {
     INTERNAL_CALL_SetTierSettingsImpl(target, tier, ref settings);
 }
 [NativeName("SetTierSettings")] extern internal static void SetTierSettingsImpl(BuildTargetGroup target, GraphicsTier tier, TierSettings settings);
 public static void SetTierSettings(NamedBuildTarget target, GraphicsTier tier, TierSettings settings) => SetTierSettings(target.ToBuildTargetGroup(), tier, settings);
 public static void SetTierSettings(BuildTargetGroup target, GraphicsTier tier, TierSettings settings)
 {
     if (settings.renderingPath == RenderingPath.UsePlayerSettings)
     {
         throw new ArgumentException("TierSettings.renderingPath must be actual rendering path (not UsePlayerSettings)", "settings");
     }
     EditorGraphicsSettings.SetTierSettingsImpl(target, tier, settings);
     EditorGraphicsSettings.MakeTierSettingsAutomatic(target, tier, false);
     EditorGraphicsSettings.OnUpdateTierSettingsImpl(target, true);
 }
    /// <summary>
    /// 设置发布选项
    /// </summary>
    /// <param name="target"></param>
    /// <param name="platform_info"></param>
    /// <param name="cache_channel_info"></param>
    /// <param name="cache_plat_info"></param>
    public static void BulidTarget(ePublishPlatformType target, PublishPlatformInfo platform_info, PublishCacheChannelInfo cache_channel_info, PublishCachePlatformInfo cache_plat_info)
    {
        BuildTarget      buildTarget = GetBuildTargetByType(target);
        BuildTargetGroup targetGroup = GetTargetGroupByType(target);

        ///1.全局
        PlayerSettings.companyName = "广州硕星";
        PlayerSettings.productName = "机甲军团";

        ///2.Resolution and Presentatio
        UIOrientation orientation = UIOrientation.LandscapeLeft;

        switch (cache_plat_info.Orientation)
        {
        case ScreenOrientation.AutoRotation: orientation = UIOrientation.AutoRotation; break;

        case ScreenOrientation.LandscapeLeft: orientation = UIOrientation.LandscapeLeft; break;

        case ScreenOrientation.LandscapeRight: orientation = UIOrientation.LandscapeRight; break;

        case ScreenOrientation.Portrait: orientation = UIOrientation.Portrait; break;

        case ScreenOrientation.PortraitUpsideDown: orientation = UIOrientation.PortraitUpsideDown; break;
        }
        PlayerSettings.defaultInterfaceOrientation = orientation;
        PlayerSettings.use32BitDisplayBuffer       = false;

        ///3.Icon

        ///4.Splash Image
        PlayerSettings.SplashScreen.show          = cache_plat_info.EnableUnitySplash;
        PlayerSettings.SplashScreen.showUnityLogo = cache_plat_info.EnableUnitySplash;

        ///5.RenderPath
        UnityEditor.Rendering.TierSettings ts = new UnityEditor.Rendering.TierSettings();
        ts.renderingPath = cache_plat_info.RenderPath;
        UnityEditor.Rendering.EditorGraphicsSettings.SetTierSettings(targetGroup, UnityEngine.Rendering.GraphicsTier.Tier2, ts);

        ///6.BundleIdentifier
        PlayerSettings.applicationIdentifier = platform_info.BundleIdentifier;
        PlayerSettings.bundleVersion         = platform_info.BundleVersion;

        ///7.预定义宏
        if (!string.IsNullOrEmpty(platform_info.CompileDefine))
        {
            PlayerSettings.SetScriptingDefineSymbolsForGroup(targetGroup, platform_info.CompileDefine);
        }

        ///8.IL2CPP
        if (target == ePublishPlatformType.Android || target == ePublishPlatformType.iOS)
        {
            switch (cache_plat_info.ScriptBackend)
            {
            case eScriptingImplementation.IL2CPP: PlayerSettings.SetScriptingBackend(targetGroup, ScriptingImplementation.IL2CPP); break;

            case eScriptingImplementation.Mono2x: PlayerSettings.SetScriptingBackend(targetGroup, ScriptingImplementation.Mono2x); break;
            }
        }

        ///9.net版本
        ApiCompatibilityLevel api_level = ApiCompatibilityLevel.NET_2_0_Subset;

        switch (cache_plat_info.ApiLevel)
        {
        case eApiCompatibilityLevel.NET_2_0: api_level = ApiCompatibilityLevel.NET_2_0; break;

        case eApiCompatibilityLevel.NET_2_0_Subset: api_level = ApiCompatibilityLevel.NET_2_0_Subset; break;
        }
        PlayerSettings.SetApiCompatibilityLevel(targetGroup, api_level);

        ///9.gpu蒙皮
        PlayerSettings.gpuSkinning = cache_plat_info.GUPSkin;

        switch (target)
        {
        case ePublishPlatformType.Android:
            HandleAndroidPlayerSetting(buildTarget, targetGroup, platform_info, cache_channel_info, cache_plat_info);
            break;

        case ePublishPlatformType.iOS:
            HandleIOSPlayerSetting(buildTarget, targetGroup, platform_info, cache_channel_info, cache_plat_info);
            break;

        case ePublishPlatformType.Win64:
        case ePublishPlatformType.Win32:
            HandleWinPlayerSetting(buildTarget, targetGroup, platform_info, cache_channel_info, cache_plat_info);
            break;

        case ePublishPlatformType.WebGL:
            HandleWebGLPlayerSetting(buildTarget, targetGroup, platform_info, cache_channel_info, cache_plat_info);
            break;
        }
    }
 public static void SetTierSettings(BuildTargetGroup target, GraphicsTier tier, TierSettings settings)
 {
     if (settings.renderingPath == RenderingPath.UsePlayerSettings)
     {
         throw new ArgumentException("TierSettings.renderingPath must be actual rendering path (not UsePlayerSettings)", "settings");
     }
     SetTierSettingsImpl(target, tier, settings);
     OnUpdateTierSettingsImpl(target, true);
 }
 public static void SetShaderSettingsForPlatform(BuildTargetGroup target, ShaderHardwareTier tier, PlatformShaderSettings settings)
 {
     TierSettings settings2 = new TierSettings {
         standardShaderQuality = settings.standardShaderQuality,
         cascadedShadowMaps = settings.cascadedShadowMaps,
         reflectionProbeBoxProjection = settings.reflectionProbeBoxProjection,
         reflectionProbeBlending = settings.reflectionProbeBlending
     };
     SetTierSettings(target, (GraphicsTier) tier, settings2);
 }
 private static extern void INTERNAL_CALL_SetTierSettingsImpl(BuildTargetGroup target, GraphicsTier tier, ref TierSettings settings);
 private static extern void INTERNAL_CALL_GetTierSettingsImpl(BuildTargetGroup target, GraphicsTier tier, out TierSettings value);
    public void OnGUI()
    {
        var resourcePath = GetResourcePath();
        var logo         = AssetDatabase.LoadAssetAtPath <Texture2D>(resourcePath + "logo.png");
        var rect         = GUILayoutUtility.GetRect(position.width, 150, GUI.skin.box);

        if (logo)
        {
            GUI.DrawTexture(rect, logo, ScaleMode.ScaleToFit);
        }

        EditorGUILayout.HelpBox("Recommended project settings for SteamVR:", MessageType.Warning);

        scrollPosition = GUILayout.BeginScrollView(scrollPosition);

        int numItems = 0;

        if (!EditorPrefs.HasKey(ignore + buildTarget) &&
            EditorUserBuildSettings.activeBuildTarget != recommended_BuildTarget)
        {
            ++numItems;

            GUILayout.Label(buildTarget + string.Format(currentValue, EditorUserBuildSettings.activeBuildTarget));

            GUILayout.BeginHorizontal();

            if (GUILayout.Button(string.Format(useRecommended, recommended_BuildTarget)))
            {
                EditorUserBuildSettings.SwitchActiveBuildTarget(BuildTargetGroup.Standalone, recommended_BuildTarget);
            }

            GUILayout.FlexibleSpace();

            if (GUILayout.Button("Ignore"))
            {
                EditorPrefs.SetBool(ignore + buildTarget, true);
            }

            GUILayout.EndHorizontal();
        }

        if (!EditorPrefs.HasKey(ignore + showUnitySplashScreen) &&
            PlayerSettings.SplashScreen.show != recommended_ShowUnitySplashScreen)
        {
            ++numItems;

            GUILayout.Label(showUnitySplashScreen + string.Format(currentValue, PlayerSettings.SplashScreen.show));

            GUILayout.BeginHorizontal();

            if (GUILayout.Button(string.Format(useRecommended, recommended_ShowUnitySplashScreen)))
            {
                PlayerSettings.SplashScreen.show = recommended_ShowUnitySplashScreen;
            }

            GUILayout.FlexibleSpace();

            if (GUILayout.Button("Ignore"))
            {
                EditorPrefs.SetBool(ignore + showUnitySplashScreen, true);
            }

            GUILayout.EndHorizontal();
        }

        if (!EditorPrefs.HasKey(ignore + defaultIsFullScreen) &&
            PlayerSettings.defaultIsFullScreen != recommended_DefaultIsFullScreen)
        {
            ++numItems;

            GUILayout.Label(defaultIsFullScreen + string.Format(currentValue, PlayerSettings.defaultIsFullScreen));

            GUILayout.BeginHorizontal();

            if (GUILayout.Button(string.Format(useRecommended, recommended_DefaultIsFullScreen)))
            {
                PlayerSettings.defaultIsFullScreen = recommended_DefaultIsFullScreen;
            }

            GUILayout.FlexibleSpace();

            if (GUILayout.Button("Ignore"))
            {
                EditorPrefs.SetBool(ignore + defaultIsFullScreen, true);
            }

            GUILayout.EndHorizontal();
        }

        if (!EditorPrefs.HasKey(ignore + defaultScreenSize) &&
            (PlayerSettings.defaultScreenWidth != recommended_DefaultScreenWidth ||
             PlayerSettings.defaultScreenHeight != recommended_DefaultScreenHeight))
        {
            ++numItems;

            GUILayout.Label(defaultScreenSize + string.Format(" ({0}x{1})", PlayerSettings.defaultScreenWidth, PlayerSettings.defaultScreenHeight));

            GUILayout.BeginHorizontal();

            if (GUILayout.Button(string.Format("Use recommended ({0}x{1})", recommended_DefaultScreenWidth, recommended_DefaultScreenHeight)))
            {
                PlayerSettings.defaultScreenWidth  = recommended_DefaultScreenWidth;
                PlayerSettings.defaultScreenHeight = recommended_DefaultScreenHeight;
            }

            GUILayout.FlexibleSpace();

            if (GUILayout.Button("Ignore"))
            {
                EditorPrefs.SetBool(ignore + defaultScreenSize, true);
            }

            GUILayout.EndHorizontal();
        }

        if (!EditorPrefs.HasKey(ignore + runInBackground) &&
            PlayerSettings.runInBackground != recommended_RunInBackground)
        {
            ++numItems;

            GUILayout.Label(runInBackground + string.Format(currentValue, PlayerSettings.runInBackground));

            GUILayout.BeginHorizontal();

            if (GUILayout.Button(string.Format(useRecommended, recommended_RunInBackground)))
            {
                PlayerSettings.runInBackground = recommended_RunInBackground;
            }

            GUILayout.FlexibleSpace();

            if (GUILayout.Button("Ignore"))
            {
                EditorPrefs.SetBool(ignore + runInBackground, true);
            }

            GUILayout.EndHorizontal();
        }

        if (!EditorPrefs.HasKey(ignore + displayResolutionDialog) &&
            PlayerSettings.displayResolutionDialog != recommended_DisplayResolutionDialog)
        {
            ++numItems;

            GUILayout.Label(displayResolutionDialog + string.Format(currentValue, PlayerSettings.displayResolutionDialog));

            GUILayout.BeginHorizontal();

            if (GUILayout.Button(string.Format(useRecommended, recommended_DisplayResolutionDialog)))
            {
                PlayerSettings.displayResolutionDialog = recommended_DisplayResolutionDialog;
            }

            GUILayout.FlexibleSpace();

            if (GUILayout.Button("Ignore"))
            {
                EditorPrefs.SetBool(ignore + displayResolutionDialog, true);
            }

            GUILayout.EndHorizontal();
        }

        if (!EditorPrefs.HasKey(ignore + resizableWindow) &&
            PlayerSettings.resizableWindow != recommended_ResizableWindow)
        {
            ++numItems;

            GUILayout.Label(resizableWindow + string.Format(currentValue, PlayerSettings.resizableWindow));

            GUILayout.BeginHorizontal();

            if (GUILayout.Button(string.Format(useRecommended, recommended_ResizableWindow)))
            {
                PlayerSettings.resizableWindow = recommended_ResizableWindow;
            }

            GUILayout.FlexibleSpace();

            if (GUILayout.Button("Ignore"))
            {
                EditorPrefs.SetBool(ignore + resizableWindow, true);
            }

            GUILayout.EndHorizontal();
        }

        if (!EditorPrefs.HasKey(ignore + fullscreenMode) &&
            PlayerSettings.d3d11FullscreenMode != recommended_FullscreenMode)
        {
            ++numItems;

            GUILayout.Label(fullscreenMode + string.Format(currentValue, PlayerSettings.d3d11FullscreenMode));

            GUILayout.BeginHorizontal();

            if (GUILayout.Button(string.Format(useRecommended, recommended_FullscreenMode)))
            {
                PlayerSettings.d3d11FullscreenMode = recommended_FullscreenMode;
            }

            GUILayout.FlexibleSpace();

            if (GUILayout.Button("Ignore"))
            {
                EditorPrefs.SetBool(ignore + fullscreenMode, true);
            }

            GUILayout.EndHorizontal();
        }

        if (!EditorPrefs.HasKey(ignore + visibleInBackground) &&
            PlayerSettings.visibleInBackground != recommended_VisibleInBackground)
        {
            ++numItems;

            GUILayout.Label(visibleInBackground + string.Format(currentValue, PlayerSettings.visibleInBackground));

            GUILayout.BeginHorizontal();

            if (GUILayout.Button(string.Format(useRecommended, recommended_VisibleInBackground)))
            {
                PlayerSettings.visibleInBackground = recommended_VisibleInBackground;
            }

            GUILayout.FlexibleSpace();

            if (GUILayout.Button("Ignore"))
            {
                EditorPrefs.SetBool(ignore + visibleInBackground, true);
            }

            GUILayout.EndHorizontal();
        }

        if (!EditorPrefs.HasKey(ignore + renderingPath) &&
            UnityEditor.Rendering.EditorGraphicsSettings.GetTierSettings(BuildTargetGroup.Standalone, UnityEngine.Rendering.GraphicsTier.Tier3).renderingPath != recommended_RenderPath)
        {
            ++numItems;

            GUILayout.Label(renderingPath + string.Format(currentValue, UnityEditor.Rendering.EditorGraphicsSettings.GetTierSettings(BuildTargetGroup.Standalone, UnityEngine.Rendering.GraphicsTier.Tier3).renderingPath));

            GUILayout.BeginHorizontal();

            if (GUILayout.Button(string.Format(useRecommended, recommended_RenderPath) + " - required for MSAA"))
            {
                UnityEditor.Rendering.TierSettings tierSettings = UnityEditor.Rendering.EditorGraphicsSettings.GetTierSettings(BuildTargetGroup.Standalone, UnityEngine.Rendering.GraphicsTier.Tier3);
                tierSettings.renderingPath = recommended_RenderPath;
                UnityEditor.Rendering.EditorGraphicsSettings.SetTierSettings(BuildTargetGroup.Standalone, UnityEngine.Rendering.GraphicsTier.Tier3, tierSettings);
            }

            GUILayout.FlexibleSpace();

            if (GUILayout.Button("Ignore"))
            {
                EditorPrefs.SetBool(ignore + renderingPath, true);
            }

            GUILayout.EndHorizontal();
        }

        if (!EditorPrefs.HasKey(ignore + colorSpace) &&
            PlayerSettings.colorSpace != recommended_ColorSpace)
        {
            ++numItems;

            GUILayout.Label(colorSpace + string.Format(currentValue, PlayerSettings.colorSpace));

            GUILayout.BeginHorizontal();

            if (GUILayout.Button(string.Format(useRecommended, recommended_ColorSpace) + " - requires reloading scene"))
            {
                PlayerSettings.colorSpace = recommended_ColorSpace;
            }

            GUILayout.FlexibleSpace();

            if (GUILayout.Button("Ignore"))
            {
                EditorPrefs.SetBool(ignore + colorSpace, true);
            }

            GUILayout.EndHorizontal();
        }

        if (!EditorPrefs.HasKey(ignore + gpuSkinning) &&
            PlayerSettings.gpuSkinning != recommended_GpuSkinning)
        {
            ++numItems;

            GUILayout.Label(gpuSkinning + string.Format(currentValue, PlayerSettings.gpuSkinning));

            GUILayout.BeginHorizontal();

            if (GUILayout.Button(string.Format(useRecommended, recommended_GpuSkinning)))
            {
                PlayerSettings.gpuSkinning = recommended_GpuSkinning;
            }

            GUILayout.FlexibleSpace();

            if (GUILayout.Button("Ignore"))
            {
                EditorPrefs.SetBool(ignore + gpuSkinning, true);
            }

            GUILayout.EndHorizontal();
        }

#if false
        if (!EditorPrefs.HasKey(ignore + singlePassStereoRendering) &&
            PlayerSettings.singlePassStereoRendering != recommended_SinglePassStereoRendering)
        {
            ++numItems;

            GUILayout.Label(singlePassStereoRendering + string.Format(currentValue, PlayerSettings.singlePassStereoRendering));

            GUILayout.BeginHorizontal();

            if (GUILayout.Button(string.Format(useRecommended, recommended_SinglePassStereoRendering)))
            {
                PlayerSettings.singlePassStereoRendering = recommended_SinglePassStereoRendering;
            }

            GUILayout.FlexibleSpace();

            if (GUILayout.Button("Ignore"))
            {
                EditorPrefs.SetBool(ignore + singlePassStereoRendering, true);
            }

            GUILayout.EndHorizontal();
        }
#endif

        GUILayout.BeginHorizontal();

        GUILayout.FlexibleSpace();

        if (GUILayout.Button("Clear All Ignores"))
        {
            EditorPrefs.DeleteKey(ignore + buildTarget);
            EditorPrefs.DeleteKey(ignore + showUnitySplashScreen);
            EditorPrefs.DeleteKey(ignore + defaultIsFullScreen);
            EditorPrefs.DeleteKey(ignore + defaultScreenSize);
            EditorPrefs.DeleteKey(ignore + runInBackground);
            EditorPrefs.DeleteKey(ignore + displayResolutionDialog);
            EditorPrefs.DeleteKey(ignore + resizableWindow);
            EditorPrefs.DeleteKey(ignore + fullscreenMode);
            EditorPrefs.DeleteKey(ignore + visibleInBackground);
            EditorPrefs.DeleteKey(ignore + renderingPath);
            EditorPrefs.DeleteKey(ignore + colorSpace);
            EditorPrefs.DeleteKey(ignore + gpuSkinning);
#if false
            EditorPrefs.DeleteKey(ignore + singlePassStereoRendering);
#endif
        }

        GUILayout.EndHorizontal();

        GUILayout.EndScrollView();

        GUILayout.FlexibleSpace();

        GUILayout.BeginHorizontal();

        if (numItems > 0)
        {
            if (GUILayout.Button("Accept All"))
            {
                // Only set those that have not been explicitly ignored.
                if (!EditorPrefs.HasKey(ignore + buildTarget))
                {
                    EditorUserBuildSettings.SwitchActiveBuildTarget(BuildTargetGroup.Standalone, recommended_BuildTarget);
                }
                if (!EditorPrefs.HasKey(ignore + showUnitySplashScreen))
                {
                    PlayerSettings.SplashScreen.show = recommended_ShowUnitySplashScreen;
                }
                if (!EditorPrefs.HasKey(ignore + defaultIsFullScreen))
                {
                    PlayerSettings.defaultIsFullScreen = recommended_DefaultIsFullScreen;
                }
                if (!EditorPrefs.HasKey(ignore + defaultScreenSize))
                {
                    PlayerSettings.defaultScreenWidth  = recommended_DefaultScreenWidth;
                    PlayerSettings.defaultScreenHeight = recommended_DefaultScreenHeight;
                }
                if (!EditorPrefs.HasKey(ignore + runInBackground))
                {
                    PlayerSettings.runInBackground = recommended_RunInBackground;
                }
                if (!EditorPrefs.HasKey(ignore + displayResolutionDialog))
                {
                    PlayerSettings.displayResolutionDialog = recommended_DisplayResolutionDialog;
                }
                if (!EditorPrefs.HasKey(ignore + resizableWindow))
                {
                    PlayerSettings.resizableWindow = recommended_ResizableWindow;
                }
                if (!EditorPrefs.HasKey(ignore + fullscreenMode))
                {
                    PlayerSettings.d3d11FullscreenMode = recommended_FullscreenMode;
                }
                if (!EditorPrefs.HasKey(ignore + visibleInBackground))
                {
                    PlayerSettings.visibleInBackground = recommended_VisibleInBackground;
                }
                if (!EditorPrefs.HasKey(ignore + renderingPath))
                {
                    UnityEditor.Rendering.TierSettings tierSettings = UnityEditor.Rendering.EditorGraphicsSettings.GetTierSettings(BuildTargetGroup.Standalone, UnityEngine.Rendering.GraphicsTier.Tier3);
                    tierSettings.renderingPath = recommended_RenderPath;
                    UnityEditor.Rendering.EditorGraphicsSettings.SetTierSettings(BuildTargetGroup.Standalone, UnityEngine.Rendering.GraphicsTier.Tier3, tierSettings);
                }
                if (!EditorPrefs.HasKey(ignore + colorSpace))
                {
                    PlayerSettings.colorSpace = recommended_ColorSpace;
                }
                if (!EditorPrefs.HasKey(ignore + gpuSkinning))
                {
                    PlayerSettings.gpuSkinning = recommended_GpuSkinning;
                }
#if false
                if (!EditorPrefs.HasKey(ignore + singlePassStereoRendering))
                {
                    PlayerSettings.singlePassStereoRendering = recommended_SinglePassStereoRendering;
                }
#endif

                EditorUtility.DisplayDialog("Accept All", "You made the right choice!", "Ok");

                Close();
            }

            if (GUILayout.Button("Ignore All"))
            {
                if (EditorUtility.DisplayDialog("Ignore All", "Are you sure?", "Yes, Ignore All", "Cancel"))
                {
                    // Only ignore those that do not currently match our recommended settings.
                    if (EditorUserBuildSettings.activeBuildTarget != recommended_BuildTarget)
                    {
                        EditorPrefs.SetBool(ignore + buildTarget, true);
                    }
                    if (PlayerSettings.SplashScreen.show != recommended_ShowUnitySplashScreen)
                    {
                        EditorPrefs.SetBool(ignore + showUnitySplashScreen, true);
                    }
                    if (PlayerSettings.defaultIsFullScreen != recommended_DefaultIsFullScreen)
                    {
                        EditorPrefs.SetBool(ignore + defaultIsFullScreen, true);
                    }
                    if (PlayerSettings.defaultScreenWidth != recommended_DefaultScreenWidth ||
                        PlayerSettings.defaultScreenHeight != recommended_DefaultScreenHeight)
                    {
                        EditorPrefs.SetBool(ignore + defaultScreenSize, true);
                    }
                    if (PlayerSettings.runInBackground != recommended_RunInBackground)
                    {
                        EditorPrefs.SetBool(ignore + runInBackground, true);
                    }
                    if (PlayerSettings.displayResolutionDialog != recommended_DisplayResolutionDialog)
                    {
                        EditorPrefs.SetBool(ignore + displayResolutionDialog, true);
                    }
                    if (PlayerSettings.resizableWindow != recommended_ResizableWindow)
                    {
                        EditorPrefs.SetBool(ignore + resizableWindow, true);
                    }
                    if (PlayerSettings.d3d11FullscreenMode != recommended_FullscreenMode)
                    {
                        EditorPrefs.SetBool(ignore + fullscreenMode, true);
                    }
                    if (PlayerSettings.visibleInBackground != recommended_VisibleInBackground)
                    {
                        EditorPrefs.SetBool(ignore + visibleInBackground, true);
                    }
                    if (UnityEditor.Rendering.EditorGraphicsSettings.GetTierSettings(BuildTargetGroup.Standalone, UnityEngine.Rendering.GraphicsTier.Tier3).renderingPath != recommended_RenderPath)
                    {
                        EditorPrefs.SetBool(ignore + renderingPath, true);
                    }
                    if (PlayerSettings.colorSpace != recommended_ColorSpace)
                    {
                        EditorPrefs.SetBool(ignore + colorSpace, true);
                    }
                    if (PlayerSettings.gpuSkinning != recommended_GpuSkinning)
                    {
                        EditorPrefs.SetBool(ignore + gpuSkinning, true);
                    }
#if false
                    if (PlayerSettings.singlePassStereoRendering != recommended_SinglePassStereoRendering)
                    {
                        EditorPrefs.SetBool(ignore + singlePassStereoRendering, true);
                    }
#endif

                    Close();
                }
            }
        }
        else if (GUILayout.Button("Close"))
        {
            Close();
        }

        GUILayout.EndHorizontal();
    }
 public static void SetTierSettings(BuildTargetGroup target, ShaderHardwareTier tier, TierSettings settings)
 {
     SetTierSettings(target, (GraphicsTier) tier, settings);
 }