https://github.com/googlevr/tilt-brush#enabling-native-oculus-support
If you open this project (Unity Version 2018.4.11f1) and upgrade to 2020.3.33f1
CS0117: 'VREditor' does not contain a definition for 'GetVREnabledDevicesOnTargetGroup'
The above error occurs, so I looked it up on Google: https://forum.unity.com/threads/steamvr-does-not-work.928503/
The solution is on this page? I found the solution on this page.
https://github.com/ValveSoftware/unity-xr-plugin When I import this one and import the latest version of SteamVR, I get the error in the title.
Is there a solution?
Here is the code with error:cs0117
//======= Copyright (c) Valve Corporation, All rights reserved. ===============
//
// Purpose: Prompt developers to use settings most compatible with SteamVR.
//
//=============================================================================
using UnityEngine;
using UnityEditor;
using System.IO;
using System.Collections.Generic;
using System.Linq;
namespace Valve.VR
{
[InitializeOnLoad]
public class SteamVR_AutoEnableVR
{
static SteamVR_AutoEnableVR()
{
EditorApplication.update += Update;
}
protected const string openVRString = "OpenVR";
protected const string openVRPackageString = "com.unity.xr.openvr.standalone";
#if UNITY_2018_2_OR_NEWER
private enum PackageStates
{
None,
WaitingForList,
WaitingForAdd,
WaitingForAddConfirm,
Installed,
Failed,
}
private static UnityEditor.PackageManager.Requests.ListRequest listRequest;
private static UnityEditor.PackageManager.Requests.AddRequest addRequest;
private static PackageStates packageState = PackageStates.None;
private static System.Diagnostics.Stopwatch addingPackageTime = new System.Diagnostics.Stopwatch();
private static System.Diagnostics.Stopwatch addingPackageTimeTotal = new System.Diagnostics.Stopwatch();
private static float estimatedTimeToInstall = 80;
private static int addTryCount = 0;
#endif
public static void Update()
{
if (SteamVR_Settings.instance.autoEnableVR)
{
bool enabledVR = false;
if (UnityEditor.PlayerSettings.virtualRealitySupported == false)
{
UnityEditor.PlayerSettings.virtualRealitySupported = true;
enabledVR = true;
Debug.Log("<b>[SteamVR Setup]</b> Enabled virtual reality support in Player Settings. (you can disable this by unchecking Assets/SteamVR/SteamVR_Settings.autoEnableVR)");
}
UnityEditor.BuildTargetGroup currentTarget = UnityEditor.EditorUserBuildSettings.selectedBuildTargetGroup;
#if (UNITY_5_4 || UNITY_5_3 || UNITY_5_2 || UNITY_5_1 || UNITY_5_0)
string[] devices = UnityEditorInternal.VR.VREditor.GetVREnabledDevices(currentTarget);
#else
string[] devices = UnityEditorInternal.VR.VREditor.GetVREnabledDevicesOnTargetGroup(currentTarget);
#endif
bool hasOpenVR = devices.Any(device => string.Equals(device, openVRString, System.StringComparison.CurrentCultureIgnoreCase));
if (hasOpenVR == false || enabledVR)
{
string[] newDevices;
if (enabledVR && hasOpenVR == false)
{
newDevices = new string[] { openVRString }; //only list openvr if we enabled it
}
else
{
List<string> devicesList = new List<string>(devices); //list openvr as the first option if it wasn't in the list.
if (hasOpenVR)
devicesList.Remove(openVRString);
devicesList.Insert(0, openVRString);
newDevices = devicesList.ToArray();
}
#if (UNITY_5_6 || UNITY_5_4 || UNITY_5_3 || UNITY_5_2 || UNITY_5_1 || UNITY_5_0)
UnityEditorInternal.VR.VREditor.SetVREnabledDevices(currentTarget, newDevices);
#else
UnityEditorInternal.VR.VREditor.SetVREnabledDevicesOnTargetGroup(currentTarget, newDevices);
#endif
Debug.Log("<b>[SteamVR Setup]</b> Added OpenVR to supported VR SDKs list.");
}
#if UNITY_2018_2_OR_NEWER
//2018+ requires us to manually add the OpenVR package
switch (packageState)
{
case PackageStates.None:
//see if we have the package
listRequest = UnityEditor.PackageManager.Client.List(true);
packageState = PackageStates.WaitingForList;
break;
case PackageStates.WaitingForList:
if (listRequest.IsCompleted)
{
if (listRequest.Error != null || listRequest.Status == UnityEditor.PackageManager.StatusCode.Failure)
{
packageState = PackageStates.Failed;
break;
}
bool hasPackage = listRequest.Result.Any(package => package.name == openVRPackageString);
if (hasPackage == false)
{
//if we don't have the package - then install it
addRequest = UnityEditor.PackageManager.Client.Add(openVRPackageString);
packageState = PackageStates.WaitingForAdd;
addTryCount++;
Debug.Log("<b>[SteamVR Setup]</b> Installing OpenVR package...");
addingPackageTime.Start();
addingPackageTimeTotal.Start();
}
else
{
//if we do have the package do nothing
packageState = PackageStates.Installed; //already installed
}
}
break;
case PackageStates.WaitingForAdd:
if (addRequest.IsCompleted)
{
if (addRequest.Error != null || addRequest.Status == UnityEditor.PackageManager.StatusCode.Failure)
{
packageState = PackageStates.Failed;
break;
}
else
{
//if the package manager says we added it then confirm that with the list
listRequest = UnityEditor.PackageManager.Client.List(true);
packageState = PackageStates.WaitingForAddConfirm;
}
}
else
{
if (addingPackageTimeTotal.Elapsed.TotalSeconds > estimatedTimeToInstall)
estimatedTimeToInstall *= 2; // :)
string dialogText;
if (addTryCount == 1)
dialogText = "Installing OpenVR from Unity Package Manager...";
else
dialogText = "Retrying OpenVR install from Unity Package Manager...";
bool cancel = UnityEditor.EditorUtility.DisplayCancelableProgressBar("SteamVR", dialogText, (float)addingPackageTimeTotal.Elapsed.TotalSeconds / estimatedTimeToInstall);
if (cancel)
packageState = PackageStates.Failed;
if (addingPackageTime.Elapsed.TotalSeconds > 10)
{
Debug.Log("<b>[SteamVR Setup]</b> Waiting for package manager to install OpenVR package...");
addingPackageTime.Stop();
addingPackageTime.Reset();
addingPackageTime.Start();
}
}
break;
case PackageStates.WaitingForAddConfirm:
if (listRequest.IsCompleted)
{
if (listRequest.Error != null)
{
packageState = PackageStates.Failed;
break;
}
bool hasPackage = listRequest.Result.Any(package => package.name == openVRPackageString);
if (hasPackage == false)
{
if (addTryCount == 1)
{
addRequest = UnityEditor.PackageManager.Client.Add(openVRPackageString);
packageState = PackageStates.WaitingForAdd;
addTryCount++;
Debug.Log("<b>[SteamVR Setup]</b> Retrying OpenVR package install...");
}
else
{
packageState = PackageStates.Failed;
}
}
else
{
packageState = PackageStates.Installed; //installed successfully
Debug.Log("<b>[SteamVR Setup]</b> Successfully installed OpenVR package.");
}
}
break;
}
if (packageState == PackageStates.Failed || packageState == PackageStates.Installed)
{
addingPackageTime.Stop();
addingPackageTimeTotal.Stop();
UnityEditor.EditorUtility.ClearProgressBar();
UnityEditor.EditorApplication.update -= Update; //we're done trying to auto-enable vr
if (packageState == PackageStates.Failed)
{
string failtext = "The Unity Package Manager failed to automatically install the OpenVR package. Please open the Package Manager Window and try to install it manually.";
UnityEditor.EditorUtility.DisplayDialog("SteamVR", failtext, "Ok");
Debug.Log("<b>[SteamVR Setup]</b> " + failtext);
}
}
#else
UnityEditor.EditorApplication.update -= Update;
#endif
}
}
}
}
Here is the code with error:cs0234
//======= Copyright (c) Valve Corporation, All rights reserved. ===============
//
// Purpose: Prompt developers to use settings most compatible with SteamVR.
//
//=============================================================================
#if (UNITY_2019_1_OR_NEWER)
using UnityEngine;
using UnityEditor;
using System.IO;
using System.Collections.Generic;
using System.Linq;
using System;
using System.Reflection;
using Valve.VR.InteractionSystem;
using UnityEditor.Callbacks;
#if OPENVR_XR_API
using UnityEditor.XR.Management.Metadata;
using UnityEngine.XR.Management;
using UnityEditor.XR.Management;
#endif
#pragma warning disable CS0618
#pragma warning disable CS0219
#pragma warning disable CS0414
namespace Valve.VR
{
#if (UNITY_2019_1_OR_NEWER && !UNITY_2020_1_OR_NEWER)
public class SteamVR_AutoEnableVR_2019to2020
{
[DidReloadScripts]
private static void OnReload()
{
#if !OPENVR_XR_API
//if we don't have xr installed, check to see if we have vr installed. if we don't have vr installed, ask which they do want to install.
SteamVR_AutoEnableVR_2019.CheckAndAsk();
#else
//since we already have xr installed, we know we just want to enable it
SteamVR_AutoEnableVR_UnityXR.EnableUnityXR();
#endif
}
}
#endif
#if (UNITY_2020_1_OR_NEWER)
public class SteamVR_AutoEnableVR_2020Plus
{
[DidReloadScripts]
private static void OnReload()
{
#if !OPENVR_XR_API
SteamVR_AutoEnableVR_UnityXR.InstallAndEnableUnityXR();
#else
//since we already have xr installed, we know we just want to enable it
SteamVR_AutoEnableVR_UnityXR.EnableUnityXR();
#endif
}
}
#endif
#if (UNITY_2019_1_OR_NEWER && !UNITY_2020_1_OR_NEWER)
public class SteamVR_AutoEnableVR_2019
{
public static void CheckAndAsk()
{
EditorApplication.update += Update;
}
protected const string openVRString = "OpenVR";
protected const string unityOpenVRPackageString = "com.unity.xr.openvr.standalone";
protected const string valveOpenVRPackageString = "com.valvesoftware.unity.openvr";
private enum PackageStates
{
None,
WaitingForList,
Complete,
Failed,
}
private static UnityEditor.PackageManager.Requests.ListRequest listRequest;
private static PackageStates packageState = PackageStates.None;
private static void End()
{
packageState = PackageStates.None;
UnityEditor.EditorUtility.ClearProgressBar();
EditorApplication.update -= Update;
}
private static void ShowDialog()
{
int shouldInstall = UnityEditor.EditorUtility.DisplayDialogComplex("SteamVR", "The SteamVR Unity Plugin can be used with the legacy Unity VR API (Unity 5.4 - 2019) or with the Unity XR API (2019+). Would you like to install in legacy VR mode or for Unity XR?", "Legacy VR", "Cancel", "Unity XR");
switch (shouldInstall)
{
case 0: //legacy vr
SteamVR_AutoEnableVR_UnityPackage.InstallAndEnableUnityVR();
break;
case 1: //cancel
break;
case 2: //unity xr
SteamVR_AutoEnableVR_UnityXR.InstallAndEnableUnityXR();
break;
}
End();
}
public static void Update()
{
if (!SteamVR_Settings.instance.autoEnableVR || Application.isPlaying)
End();
if (UnityEditor.PlayerSettings.virtualRealitySupported == false)
{
ShowDialog();
return;
}
switch (packageState)
{
case PackageStates.None:
//see if we have the package
listRequest = UnityEditor.PackageManager.Client.List(true);
packageState = PackageStates.WaitingForList;
break;
case PackageStates.WaitingForList:
if (listRequest.IsCompleted)
{
if (listRequest.Error != null || listRequest.Status == UnityEditor.PackageManager.StatusCode.Failure)
{
packageState = PackageStates.Failed;
break;
}
string packageName = unityOpenVRPackageString;
bool hasPackage = listRequest.Result.Any(package => package.name == packageName);
if (hasPackage == false)
ShowDialog();
else //if we do have the package, do nothing
End();
}
break;
case PackageStates.Failed:
End();
string failtext = "The Unity Package Manager failed to verify the OpenVR package. If you were trying to install it you may need to open the Package Manager Window and try to install it manually.";
UnityEditor.EditorUtility.DisplayDialog("SteamVR", failtext, "Ok");
Debug.Log("<b>[SteamVR Setup]</b> " + failtext);
break;
}
}
}
#endif
// todo: split the below into an install and an enable section
public class SteamVR_AutoEnableVR_UnityXR
{
public static void InstallAndEnableUnityXR()
{
StartXRInstaller();
EditorApplication.update += Update;
}
public static void EnableUnityXR()
{
EditorApplication.update += Update;
}
protected const string openVRString = "OpenVR";
protected const string unityOpenVRPackageString = "com.unity.xr.openvr.standalone";
protected const string valveOpenVRPackageString = "com.valvesoftware.unity.openvr";
private enum PackageStates
{
None,
WaitingForList,
WaitingForAdd,
WaitingForAddConfirm,
Installed,
Failed,
}
private static UnityEditor.PackageManager.Requests.ListRequest listRequest;
private static UnityEditor.PackageManager.Requests.AddRequest addRequest;
private static PackageStates packageState = PackageStates.None;
private static System.Diagnostics.Stopwatch addingPackageTime = new System.Diagnostics.Stopwatch();
private static System.Diagnostics.Stopwatch addingPackageTimeTotal = new System.Diagnostics.Stopwatch();
private static float estimatedTimeToInstall = 80;
private static int addTryCount = 0;
private static string enabledLoaderKey = null;
private static MethodInfo isLoaderAssigned;
private static MethodInfo installPackageAndAssignLoaderForBuildTarget;
private static Type[] isLoaderAssignedMethodParameters;
private static object[] isLoaderAssignedCallParameters;
private static void End()
{
addingPackageTime.Stop();
addingPackageTimeTotal.Stop();
UnityEditor.EditorUtility.ClearProgressBar();
EditorApplication.update -= Update;
}
public static void Update()
{
if (!SteamVR_Settings.instance.autoEnableVR)
End();
#if OPENVR_XR_API
EnableLoader();
#endif
}
#if OPENVR_XR_API
private static EditorWindow settingsWindow = null;
private static int skipEditorFrames = 5;
public static void EnableLoader()
{
if (skipEditorFrames > 0)
{
skipEditorFrames--;
return;
}
if (enabledLoaderKey == null)
enabledLoaderKey = string.Format(valveEnabledLoaderKeyTemplate, SteamVR_Settings.instance.editorAppKey);
if (EditorPrefs.HasKey(enabledLoaderKey) == false)
{
if (UnityEditor.PlayerSettings.virtualRealitySupported == true)
{
UnityEditor.PlayerSettings.virtualRealitySupported = false;
Debug.Log("<b>[SteamVR Setup]</b> Disabled virtual reality support in Player Settings. <b>Because you're using XR Manager. Make sure OpenVR Loader is enabled in XR Manager UI.</b> (you can disable this by unchecking Assets/SteamVR/SteamVR_Settings.autoEnableVR)");
}
var generalSettings = XRGeneralSettingsPerBuildTarget.XRGeneralSettingsForBuildTarget(BuildTargetGroup.Standalone);
if (generalSettings == null)
{
if (settingsWindow == null)
{
settingsWindow = SettingsService.OpenProjectSettings("Project/XR Plug-in Management");
settingsWindow.Repaint();
return;
}
if (settingsWindow == null || generalSettings == null)
{
Debug.LogWarning("<b>[SteamVR Setup]</b> Unable to access standalone xr settings while trying to enable OpenVR Loader. <b>You may need to manually enable OpenVR Loader in XR Plug-in Management (Project Settings).</b> (you can disable this by unchecking Assets/SteamVR/SteamVR_Settings.autoEnableVR)");
return;
}
}
if (generalSettings.AssignedSettings == null)
{
var assignedSettings = ScriptableObject.CreateInstance<XRManagerSettings>() as XRManagerSettings;
generalSettings.AssignedSettings = assignedSettings;
EditorUtility.SetDirty(generalSettings);
}
bool existing = generalSettings.AssignedSettings.loaders.Any(loader => loader.name == valveOpenVRLoaderType);
foreach (var loader in generalSettings.AssignedSettings.loaders)
{
Debug.Log("loader: " + loader.name);
}
if (!existing)
{
bool status = XRPackageMetadataStore.AssignLoader(generalSettings.AssignedSettings, valveOpenVRLoaderType, BuildTargetGroup.Standalone);
if (status)
Debug.Log("<b>[SteamVR Setup]</b> Enabled OpenVR Loader in XR Management");
else
Debug.LogError("<b>[SteamVR Setup]</b> Failed to enable enable OpenVR Loader in XR Management. You may need to manually open the XR Plug-in Management tab in project settings and check the OpenVR Loader box.");
}
EditorPrefs.SetBool(enabledLoaderKey, true);
}
End();
}
#endif
protected const string valveEnabledLoaderKeyTemplate = "valve.enabledxrloader.{0}";
protected const string valveOpenVRLoaderType = "Unity.XR.OpenVR.OpenVRLoader";
private static void StartXRInstaller()
{
Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
for (int assemblyIndex = 0; assemblyIndex < assemblies.Length; assemblyIndex++)
{
Assembly assembly = assemblies[assemblyIndex];
Type type = assembly.GetType("Unity.XR.OpenVR.OpenVRPackageInstaller");
if (type != null)
{
MethodInfo preinitMethodInfo = type.GetMethod("Start");
if (preinitMethodInfo != null)
{
preinitMethodInfo.Invoke(null, new object[] { true });
return;
}
}
}
}
}
}
#endif