public static void UpdateTrackerIDList()
{
EVRInitError initError = EVRInitError.None;
OpenVR.Init(ref initError, EVRApplicationType.VRApplication_Overlay);
List <string> hardwareIDList = new List <string>();
for (uint n = 0; n < Constants.MAX_OPENVR_OBJECTS; n++)
{
ETrackedDeviceClass deviceClass = OpenVR.System.GetTrackedDeviceClass(n);
if (deviceClass == ETrackedDeviceClass.GenericTracker)
{
hardwareIDList.Add(TrackedObjectID.GetHardwareIDFromIndex((int)n));
}
}
// EditorPrefs cannot store lists but can store anything as a string, so convert the list to JSON and save that instead
string trackerListJson = JsonUtility.ToJson(new TrackerList(hardwareIDList));
EditorPrefs.SetString(TrackerListPrefLocation, trackerListJson);
// Properly close reference to SteamVR so it can be access safely again later
OpenVR.Shutdown();
}
public OpenVRInterface()
{
if (CoreSettings.CoreSettings.Default.UseTracking)
{
OpenVR.Init(ref EVRerror, EVRApplicationType.VRApplication_Overlay);
if (EVRerror != EVRInitError.None)
{
// throw new Exception("An error occured while initializing OpenVR!");
}
OpenVR.GetGenericInterface(OpenVR.IVRCompositor_Version, ref EVRerror);
if (EVRerror != EVRInitError.None)
{
// throw new Exception("An error occured while initializing Compositor!");
}
OpenVR.GetGenericInterface(OpenVR.IVROverlay_Version, ref EVRerror);
if (EVRerror != EVRInitError.None)
{
// throw new Exception("An error occured while initializing Overlay!");
}
SetupDevices();
}
else
{
EVRerror = EVRInitError.Unknown;
}
}
private static void ReportError(EVRInitError error)
{
if (error != EVRInitError.None)
{
if (error != EVRInitError.Init_VRClientDLLNotFound)
{
if (error != EVRInitError.Driver_RuntimeOutOfDate)
{
if (error != EVRInitError.VendorSpecific_UnableToConnectToOculusRuntime)
{
Debug.Log(OpenVR.GetStringForHmdError(error));
}
else
{
Debug.Log("SteamVR Initialization Failed! Make sure device is on, Oculus runtime is installed, and OVRService_*.exe is running.");
}
}
else
{
Debug.Log("SteamVR Initialization Failed! Make sure device's runtime is up to date.");
}
}
else
{
Debug.Log("SteamVR drivers not found! They can be installed via Steam under Library > Tools. Visit http://steampowered.com to install Steam.");
}
}
}
public static bool init()
{
EVRInitError error = EVRInitError.None;
vrSystem = OpenVR.Init(ref error, EVRApplicationType.VRApplication_Scene);
if (error != EVRInitError.None)
{
Warn.print("Error initializing OpenVR: {0}", error);
return(false);
}
if (OpenVR.Compositor == null)
{
Warn.print("Failed to initialize OpenVR compositor");
return(false);
}
//setup a seated environment
OpenVR.Compositor.SetTrackingSpace(ETrackingUniverseOrigin.TrackingUniverseSeated);
Info.print("OpenVR Manufacturer: {0}", getTrackedDeviceString(ETrackedDeviceProperty.Prop_ManufacturerName_String));
Info.print("OpenVR Model Number: {0}", getTrackedDeviceString(ETrackedDeviceProperty.Prop_ModelNumber_String));
Info.print("OpenVR Tracking System: {0}", getTrackedDeviceString(ETrackedDeviceProperty.Prop_TrackingSystemName_String));
Info.print("OpenVR Driver Version: {0}", getTrackedDeviceString(ETrackedDeviceProperty.Prop_DriverVersion_String));
return(true);
}
public static bool InitializeTemporarySession(bool initInput = false)
{
if (Application.isEditor)
{
//bool needsInit = (!active && !usingNativeSupport && !runningTemporarySession);
EVRInitError initError = EVRInitError.None;
OpenVR.GetGenericInterface(OpenVR.IVRCompositor_Version, ref initError);
bool needsInit = initError != EVRInitError.None;
if (needsInit)
{
EVRInitError error = EVRInitError.None;
OpenVR.Init(ref error, EVRApplicationType.VRApplication_Overlay);
if (error != EVRInitError.None)
{
Debug.LogError("<b>[SteamVR]</b> Error during OpenVR Init: " + error.ToString());
return(false);
}
IdentifyEditorApplication(false);
//SteamVR_Input.IdentifyActionsFile(false);
runningTemporarySession = true;
}
return(needsInit);
}
return(false);
}
/// <summary>
/// Takes the SteamVR TrackedObject and finds the current SteamVR index based on the hardware ID.
/// </summary>
public void AssignIndex()
{
trackedObject = gameObject.GetComponent <SteamVR_TrackedObject>();
if (trackedObject == null)
{
trackedObject = gameObject.AddComponent <SteamVR_TrackedObject>();
}
// Set the index to none to make sure it doesn't get assigned to the wrong index
trackedObject.index = SteamVR_TrackedObject.EIndex.None;
// Make sure the SteamVR context is valid, if not, open a new SteamVR instance so you can pull the tracker data
if (OpenVR.System == null)
{
EVRInitError initError = EVRInitError.None;
OpenVR.Init(ref initError, EVRApplicationType.VRApplication_Background);
}
// Traverse through all the connected IDs looking for this Hardware's current ID
// Note OpenVR 0 is reserved for the HMD, so skip those index since it will never be the right one
for (int n = 1; n < Constants.MAX_OPENVR_OBJECTS; n++)
{
string currentID = GetHardwareIDFromIndex(n);
if (currentID == trackerHardwareID)
{
trackedObject.index = (SteamVR_TrackedObject.EIndex)n;
break;
}
}
}
public void InitOpenVR()
{
ExtenFunctions.SetDllDirectory(OpenVRDllPath);
if (!OpenVR.IsHmdPresent())
{
throw new InvalidOperationException("Could not find vr headset");
}
if (!OpenVR.IsRuntimeInstalled())
{
throw new InvalidOperationException("Could not find openVr runtime");
}
EVRInitError hmdInitErrorCode = EVRInitError.None;
OpenVR.Init(ref hmdInitErrorCode, EVRApplicationType.VRApplication_Scene);
if (hmdInitErrorCode != EVRInitError.None)
{
throw new Exception("OpenVR error: " + OpenVR.GetStringForHmdError(hmdInitErrorCode));
}
OpenVR.System.ResetSeatedZeroPose();
uint renderTextureWidth = 0;
uint renderTextureHeight = 0;
OpenVR.System.GetRecommendedRenderTargetSize(ref renderTextureWidth, ref renderTextureHeight);
VRManager.Instance.InitEyeTextures((int)renderTextureWidth, (int)renderTextureHeight);
}
public static void Init()
{
if (NativeMethods.LoadLibrary("openvr_api") == IntPtr.Zero)
{
throw new OpenVRInitException("OpenVR API is not loaded");
}
if (string.Compare(XRSettings.loadedDeviceName, "OpenVR", StringComparison.InvariantCultureIgnoreCase) != 0)
{
throw new OpenVRInitException($"OpenVR is not the selected VR SDK ({XRSettings.loadedDeviceName})");
}
if (!OpenVRWrapper.isRuntimeInstalled)
{
throw new OpenVRInitException("OpenVR runtime is not installed");
}
EVRInitError error = EVRInitError.None;
CVRSystem system = OpenVR.Init(ref error);
if (error != EVRInitError.None)
{
throw new OpenVRInitException(error);
}
if (system == null)
{
throw new OpenVRInitException("OpenVR.Init returned null");
}
isInitialized = true;
}
public override Vector3 GetPlayspaceBounds()
{
bool initOpenVR = (!SteamVR.active && !SteamVR.usingNativeSupport);
if (initOpenVR)
{
EVRInitError error = EVRInitError.None;
OpenVR.Init(ref error, EVRApplicationType.VRApplication_Other);
}
CVRChaperone chaperone = OpenVR.Chaperone;
if (chaperone != null)
{
chaperone.GetPlayAreaSize(ref PlayspaceBounds.x, ref PlayspaceBounds.z);
PlayspaceBounds.y = 1;
}
if (initOpenVR)
{
OpenVR.Shutdown();
}
return(PlayspaceBounds);
}
public void Init(EVRApplicationType ApplicationType = EVRApplicationType.VRApplication_Overlay)
{
//Dummy OpenTK Window
GameWindow window = new GameWindow(300, 300);
EVRInitError error = EVRInitError.None;
OpenVR.Init(ref error, ApplicationType);
if (error != EVRInitError.None)
{
throw new Exception("An error occured while initializing OpenVR!");
}
OpenVR.GetGenericInterface(OpenVR.IVRCompositor_Version, ref error);
if (error != EVRInitError.None)
{
throw new Exception("An error occured while initializing Compositor!");
}
OpenVR.GetGenericInterface(OpenVR.IVROverlay_Version, ref error);
if (error != EVRInitError.None)
{
throw new Exception("An error occured while initializing Overlay!");
}
System.Threading.Thread OverlayThread = new System.Threading.Thread(new System.Threading.ThreadStart(OverlayCycle));
OverlayThread.IsBackground = true;
OverlayThread.Start();
}
private static SteamVR CreateInstance()
{
try
{
EVRInitError evrinitError = EVRInitError.None;
if (!SteamVR.usingNativeSupport)
{
Debug.Log("OpenVR initialization failed. Ensure 'Virtual Reality Supported' is checked in Player Settings, and OpenVR is added to the list of Virtual Reality SDKs.");
return(null);
}
OpenVR.GetGenericInterface("IVRCompositor_022", ref evrinitError);
if (evrinitError != EVRInitError.None)
{
SteamVR.ReportError(evrinitError);
return(null);
}
OpenVR.GetGenericInterface("IVROverlay_018", ref evrinitError);
if (evrinitError != EVRInitError.None)
{
SteamVR.ReportError(evrinitError);
return(null);
}
}
catch (Exception message)
{
Debug.LogError(message);
return(null);
}
return(new SteamVR());
}
public static void Init()
{
if (!string.Equals(XRSettings.loadedDeviceName, "OpenVR", StringComparison.InvariantCultureIgnoreCase))
{
throw new OpenVRInitException($"OpenVR is not the selected VR SDK ({XRSettings.loadedDeviceName})");
}
if (!OpenVRFacade.IsRuntimeInstalled())
{
throw new OpenVRInitException("OpenVR runtime is not installed");
}
EVRInitError error = EVRInitError.None;
CVRSystem system = OpenVR.Init(ref error);
if (error != EVRInitError.None)
{
throw new OpenVRInitException(error);
}
if (system == null)
{
throw new OpenVRInitException("OpenVR.Init returned null");
}
isInitialized = true;
}
public static bool InitializeTemporarySession(bool initInput = false)
{
if (Application.isEditor)
{
EVRInitError evrinitError = EVRInitError.None;
OpenVR.GetGenericInterface("IVRCompositor_022", ref evrinitError);
bool flag = evrinitError > EVRInitError.None;
if (flag)
{
EVRInitError evrinitError2 = EVRInitError.None;
OpenVR.Init(ref evrinitError2, EVRApplicationType.VRApplication_Overlay, "");
if (evrinitError2 != EVRInitError.None)
{
UnityEngine.Debug.LogError("<b>[SteamVR_Standalone]</b> Error during OpenVR Init: " + evrinitError2.ToString());
return(false);
}
SteamVR.IdentifyEditorApplication(false);
SteamVR_Input.IdentifyActionsFile(false);
SteamVR.runningTemporarySession = true;
}
if (initInput)
{
SteamVR_Input.Initialize(true);
}
return(flag);
}
return(false);
}
static void ReportError(EVRInitError error)
{
switch (error)
{
case EVRInitError.None:
break;
case EVRInitError.VendorSpecific_UnableToConnectToOculusRuntime:
Debug.LogWarning(
"<b>[SteamVR]</b> Initialization Failed! Make sure device is on, Oculus runtime is installed, and OVRService_*.exe is running.");
break;
case EVRInitError.Init_VRClientDLLNotFound:
Debug.LogWarning(
"<b>[SteamVR]</b> Drivers not found! They can be installed via Steam under Library > Tools. Visit http://steampowered.com to install Steam.");
break;
case EVRInitError.Driver_RuntimeOutOfDate:
Debug.LogWarning(
"<b>[SteamVR]</b> Initialization Failed! Make sure device's runtime is up to date.");
break;
default:
Debug.LogWarning("<b>[SteamVR]</b> " + OpenVR.GetStringForHmdError(error));
break;
}
}
public bool Initialize()
{
if (!m_initialized)
{
EVRInitError l_initError = EVRInitError.None;
m_vrSystem = OpenVR.Init(ref l_initError, EVRApplicationType.VRApplication_Overlay);
if (l_initError == EVRInitError.None)
{
OpenVR.Overlay.CreateOverlay("leap.control.notification", "Ultraleap Control", ref m_notificationOverlay);
// Find fake Leap Motion station device
for (uint i = 0; i < OpenVR.k_unMaxTrackedDeviceCount; i++)
{
ETrackedPropertyError l_propertyError = ETrackedPropertyError.TrackedProp_Success;
ulong l_property = m_vrSystem.GetUint64TrackedDeviceProperty(i, ETrackedDeviceProperty.Prop_VendorSpecific_Reserved_Start, ref l_propertyError);
if ((l_propertyError == ETrackedPropertyError.TrackedProp_Success) && (l_property == 0x4C4D6F74696F6E))
{
m_leapDevice = i;
break;
}
}
m_initialized = true;
m_active = true;
}
else
{
System.Windows.Forms.MessageBox.Show("Unable to initialize OpenVR: " + Valve.VR.OpenVR.GetStringForHmdError(l_initError), "Driver Leap Control");
}
}
return(m_initialized);
}
//public Screen getMainScreen()
//{
// for (int i = 0; i < Screen.AllScreens.Length; i++)
// {
// Screen scr = Screen.AllScreens[i];
// if (scr.Bounds.X == 0 && scr.Bounds.Y == 0)
// {
// return scr;
// }
// }
// return Screen.AllScreens[0];
//}
//public Screen getSecondScreen()
//{
// for (int i = 0; i < Screen.AllScreens.Length; i++)
// {
// Screen scr = Screen.AllScreens[i];
// if ((scr.Bounds.X != 0 || scr.Bounds.Y != 0) && !(scr.Bounds.X == 0 && scr.Bounds.Y == 0))
// {
// return scr;
// }
// }
// return Screen.AllScreens[0];
//}
void OnGUI()
{
if (GUI.Button(new Rect(200, 200, 200, 200), "OpenGame"))
{
VRSettings.enabled = false;
OpenVR.ShutdownInternal();
//Application.OpenURL("D:/testgame/Game/备选/Knockout/Knockout.exe");
StartProcess("D:/testgame/Game/备选/Knockout/Knockout.exe");
//StartProcess(@"D:/testgame/Game/备选/HoloBall光之球/HoloBall/HoloBall.exe");
//SetWindowLong(GetActiveWindow(), GWL_STYLE, WS_BORDER);
SetWindowPos(OpenWin, -1, (int)screenPosition.x, (int)screenPosition.y, (int)screenPosition.width, (int)screenPosition.height, SWP_SHOWWINDOW);
}
if (GUI.Button(new Rect(500, 200, 200, 200), "CloseGame"))
{
//KillProcess("Knockout");
if (proo != null && !proo.HasExited)
{
proo.Kill();
proo = null;
}
EVRInitError a = EVRInitError.None;
OpenVR.InitInternal(ref a, EVRApplicationType.VRApplication_Scene);
VRSettings.enabled = true;
}
}
public MainWindow()
{
InitializeComponent();
AddEventListener();
InitializeDragList();
InitializeViewport();
InitializeBatteryImagePath();
ComponentDispatcher.ThreadIdle += new EventHandler(SetImage);
ComponentDispatcher.ThreadIdle += new EventHandler(SetBattery);
ComponentDispatcher.ThreadIdle += new EventHandler(GetRAMUsage);
ComponentDispatcher.ThreadIdle += new EventHandler(SetPCPerformance);
timer.Enabled = true;
timer.Start();
timer.Elapsed += GetCPUUsage;
timer.Elapsed += GetCPUUsageWMI;
timer.AutoReset = true;
//Initialize OpenVR & SteamVR and launch SteamVR application
EVRInitError initError = new EVRInitError();
OpenVR.Init(ref initError, EVRApplicationType.VRApplication_VRMonitor);
GetViveControllerBattery();
//Set DataContext of [plot1] to find its resources from another class (i.e. MainViewModel) other than [MainWindow] class
MainViewModel m = new MainViewModel();
plot1.DataContext = m;
}
void Awake()
{
Screen.SetResolution(550, 150, false);
EVRInitError error2 = default(EVRInitError);
OpenVR.Init(ref error2, EVRApplicationType.VRApplication_Overlay);
Debug.Log("awake");
var overlay = OpenVR.Overlay;
if (overlay != null)
{
var error = overlay.CreateOverlay(key, gameObject.name, ref handle);
if (error != EVROverlayError.None)
{
Debug.Log(overlay.GetOverlayErrorNameFromEnum(error));
enabled = false;
return;
}
if (sideBySideStereo)
{
overlay.SetOverlayFlag(handle, VROverlayFlags.SideBySide_Parallel, true); // set overlay to sideby side
}
}
SteamVR_Overlay.instance = this;
}
static void InitOpenVR()
{
EVRInitError ovrError = EVRInitError.None;
OpenVR.Init(ref ovrError, EVRApplicationType.VRApplication_Overlay);
if (ovrError != EVRInitError.None)
{
throw new Exception("Failed to init OpenVR! " + ovrError.ToString());
}
OpenVR.GetGenericInterface(OpenVR.IVRCompositor_Version, ref ovrError);
if (ovrError != EVRInitError.None)
{
throw new Exception("Failed to init Compositor! " + ovrError.ToString());
}
OpenVR.GetGenericInterface(OpenVR.IVROverlay_Version, ref ovrError);
if (ovrError != EVRInitError.None)
{
throw new Exception("Failed to init Overlay!");
}
SteamVR_Event.Listen("new_poses", OnNewPoses);
SteamVR_Event.Listen("KeyboardDone", OnKeyboardDone);
SteamVR_Event.Listen("KeyboardCharInput", OnKeyboardCharInput);
SteamVR_Event.Listen("KeyboardClosed", OnKeyboardClosed);
}
public override bool Initialize()
{
#if UNITY_INPUT_SYSTEM
//InputLayoutLoader.RegisterInputLayouts();
#endif
//this only works at the right time in editor. In builds we use a different method (reading the asset manually)
#if UNITY_EDITOR
OpenVRSettings settings = OpenVRSettings.GetSettings();
if (settings != null)
{
if (string.IsNullOrEmpty(settings.EditorAppKey))
{
settings.EditorAppKey = settings.GenerateEditorAppKey();
}
UserDefinedSettings userDefinedSettings;
userDefinedSettings.stereoRenderingMode = (ushort)settings.GetStereoRenderingMode();
userDefinedSettings.initializationType = (ushort)settings.GetInitializationType();
userDefinedSettings.applicationName = null;
userDefinedSettings.editorAppKey = null;
userDefinedSettings.mirrorViewMode = (ushort)settings.GetMirrorViewMode();
userDefinedSettings.editorAppKey = settings.EditorAppKey; //only set the key if we're in the editor. Otherwise let steamvr set the key.
if (OpenVRHelpers.IsUsingSteamVRInput())
{
userDefinedSettings.editorAppKey = OpenVRHelpers.GetEditorAppKeyFromPlugin();
}
userDefinedSettings.applicationName = string.Format("[Testing] {0}", GetEscapedApplicationName());
settings.InitializeActionManifestFileRelativeFilePath();
userDefinedSettings.actionManifestPath = settings.ActionManifestFileRelativeFilePath;
SetUserDefinedSettings(userDefinedSettings);
}
#endif
CreateSubsystem <XRDisplaySubsystemDescriptor, XRDisplaySubsystem>(s_DisplaySubsystemDescriptors, "OpenVR Display");
EVRInitError result = GetInitializationResult();
if (result != EVRInitError.None)
{
DestroySubsystem <XRDisplaySubsystem>();
Debug.LogError("<b>[OpenVR]</b> Could not initialize OpenVR. Error code: " + result.ToString());
return(false);
}
CreateSubsystem <XRInputSubsystemDescriptor, XRInputSubsystem>(s_InputSubsystemDescriptors, "OpenVR Input");
OpenVREvents.Initialize();
TickCallbackDelegate callback = TickCallback;
RegisterTickCallback(callback);
callback(0);
return(displaySubsystem != null && inputSubsystem != null);
}
public static bool GetBounds(Size size, ref HmdQuad_t pRect)
{
if (size == Size.Calibrated)
{
bool initOpenVR = (!SteamVR.active && !SteamVR.usingNativeSupport);
if (initOpenVR)
{
EVRInitError error = EVRInitError.None;
OpenVR.Init(ref error, EVRApplicationType.VRApplication_Other);
}
CVRChaperone chaperone = OpenVR.Chaperone;
bool success = (chaperone != null) && chaperone.GetPlayAreaRect(ref pRect);
if (!success)
{
Debug.LogWarning("Failed to get Calibrated Play Area bounds! Make sure you have tracking first, and that your space is calibrated.");
}
if (initOpenVR)
{
OpenVR.Shutdown();
}
return(success);
}
else
{
try
{
string str = size.ToString().Substring(1);
string[] arr = str.Split(new char[] { 'x' }, 2);
// convert to half size in meters (from cm)
float x = float.Parse(arr[0]) / 200;
float z = float.Parse(arr[1]) / 200;
pRect.vCorners0.v0 = x;
pRect.vCorners0.v1 = 0;
pRect.vCorners0.v2 = -z;
pRect.vCorners1.v0 = -x;
pRect.vCorners1.v1 = 0;
pRect.vCorners1.v2 = -z;
pRect.vCorners2.v0 = -x;
pRect.vCorners2.v1 = 0;
pRect.vCorners2.v2 = z;
pRect.vCorners3.v0 = x;
pRect.vCorners3.v1 = 0;
pRect.vCorners3.v2 = z;
return(true);
}
catch { }
}
return(false);
}
/// <summary>
/// Reports the initialization error.
/// </summary>
/// <param name="error">The error.</param>
public static void ReportInitError(EVRInitError error)
{
if (error == EVRInitError.None)
{
return;
}
//TODO: Don't log to Debug, since this is visible in editor console
Debug.LogError("[VR] Init error: `" + OpenVR.GetStringForHmdError(error) + "`");
}
private void TrackingLoop()
{
try
{
EVRInitError initError = EVRInitError.None;
CVRSystem cvrSystem = OpenVR.Init(ref initError, EVRApplicationType.VRApplication_Utility);
var chaperone = OpenVR.Chaperone;
var quadArea = new HmdQuad_t();
chaperone.GetPlayAreaRect(ref quadArea);
_playArea = quadArea.ToPlayArea();
if (initError != EVRInitError.None)
{
throw new InvalidOperationException($"EVR init erro: {initError}");
}
while (_keepReading)
{
TrackedDevicePose_t[] trackedDevicePoses = new TrackedDevicePose_t[OpenVR.k_unMaxTrackedDeviceCount];
cvrSystem.GetDeviceToAbsoluteTrackingPose(ETrackingUniverseOrigin.TrackingUniverseStanding, 0f, trackedDevicePoses);
for (uint trackedDeviceIndex = 0; trackedDeviceIndex < OpenVR.k_unMaxTrackedDeviceCount; trackedDeviceIndex++)
{
if (cvrSystem.IsTrackedDeviceConnected(trackedDeviceIndex))
{
ETrackedDeviceClass deviceClass = cvrSystem.GetTrackedDeviceClass(trackedDeviceIndex);
if (true)
{
VRControllerState_t controllerState = new VRControllerState_t();
cvrSystem.GetControllerState(1, ref controllerState, (uint)System.Runtime.InteropServices.Marshal.SizeOf(typeof(VRControllerState_t)));
ETrackingResult trackingResult = trackedDevicePoses[trackedDeviceIndex].eTrackingResult;
bool trigger = controllerState.rAxis1.x > 0.9f;
bool menuButton = (controllerState.ulButtonPressed & (1ul << (int)EVRButtonId.k_EButton_ApplicationMenu)) != 0;
bool gripButton = (controllerState.ulButtonPressed & (1ul << (int)EVRButtonId.k_EButton_Grip)) != 0;
if (trackingResult == ETrackingResult.Running_OK)
{
HmdMatrix34_t trackingMatrix = trackedDevicePoses[trackedDeviceIndex].mDeviceToAbsoluteTracking;
Vector3 speedVector = trackedDevicePoses[trackedDeviceIndex].vVelocity.ToVelocityVector();
Vector3 position = trackingMatrix.ToPositionVector();
DeviceTrackingData trackingUpdate = new DeviceTrackingData((int)trackedDeviceIndex, deviceClass.ToString(), position, trackingMatrix.ToRotationQuaternion());
NewPoseUpdate?.Invoke(this, trackingUpdate);
}
}
}
}
Thread.Sleep(UpdatedInterval);
}
}
catch (Exception e)
{
Console.WriteLine($"Error: {e}");
}
finally
{
OpenVR.Shutdown();
}
}
public ControllerTracking(int pUserId, string pSessionId, TcpSocketManager pTcpSocketManager)
{
userId = pUserId;
sessionId = pSessionId;
tcpSocketManager = pTcpSocketManager;
EVRInitError eError = EVRInitError.None;
vr_pointer = OpenVR.Init(ref eError, EVRApplicationType.VRApplication_Background);
}
public bool InitializeOpenVR()
{
EVRInitError initError = EVRInitError.None;
vrSystem = OpenVR.Init(ref initError, EVRApplicationType.VRApplication_Background);
status = initError == EVRInitError.None ? AgentStatus.Ready : AgentStatus.Error; // TODO: specify, why error happened.
return(initError == EVRInitError.None);
}
public static void Init(EVRApplicationType eApplicationType = EVRApplicationType.VRApplication_Scene)
{
EVRInitError peError = EVRInitError.None;
OpenVR.Init(ref peError, eApplicationType);
if (peError != EVRInitError.None)
{
throw OpenVRException.Make(peError);
}
}
public LighthouseTracking()
{
EVRInitError eError = EVRInitError.None;
m_pHMD = OpenVR.Init(ref eError, EVRApplicationType.VRApplication_Background);
if (eError != EVRInitError.None)
{
m_pHMD = null;
string errMsg = "Unable to init VR runtime: %s";
}
}
/// <summary>
/// Allows for the Editor to assign the index of a SteamVR Tracked Object at Editor time.
/// </summary>
public void AssignIndex()
{
EVRInitError initError = EVRInitError.None;
OpenVR.Init(ref initError, EVRApplicationType.VRApplication_Overlay);
(serializedObject.targetObject as TrackedObjectID).AssignIndex();
// Properly close reference to SteamVR so it can be access safely again later
OpenVR.Shutdown();
}
private bool ErrorCheck(EVRInitError error)
{
bool err = (error != EVRInitError.None);
if (err)
{
Debug.Log("VR Error: " + OpenVR.GetStringForHmdError(error));
}
return(err);
}
public static bool InitHMD()
{
if (initialized)
{
return(false); //Already initialized
}
EVRInitError error = EVRInitError.None;
CVRSystem vrSystem = OpenVR.Init(ref error, EVRApplicationType.VRApplication_Background);
if (error != EVRInitError.None)
{
Console.WriteLine("OpenVR init error: " + error);
return(false);
}
//vrSystem.ResetSeatedZeroPose();
{
string filePath = string.Concat(Directory.GetCurrentDirectory(), "\\bindings\\actions.json");
if (!File.Exists(filePath))
{
Console.WriteLine("File {0} doesn't exist!", filePath);
return(false);
}
EVRInputError err = OpenVR.Input.SetActionManifestPath(filePath);
if (err != EVRInputError.None)
{
Console.WriteLine("OpenVR SetActionManifestPath error: {0}", err);
return(false);
}
}
if (!EnumerateDevices())
{
return(false);
}
vibrationHandle = 0;
{
EVRInputError err = OpenVR.Input.GetActionHandle("/actions/default/out/haptic", ref vibrationHandle);
if (err != EVRInputError.None)
{
Console.WriteLine("OpenVR GetActionHandle error: {0}", err);
return(false);
}
}
InitActionSet();
int periodMS = 500;
Timer timer = new Timer(Refresh, null, 0, periodMS);
Refresh(null);
//wait for the timer to start
Thread.Sleep(periodMS);
initialized = true;
return(true);
}
internal static extern IntPtr GetStringForHmdError(EVRInitError error);
public static IntPtr Init(ref EVRInitError peError, EVRApplicationType eApplicationType = EVRApplicationType.VRApplication_Scene)
{
return OpenVRInterop.Init(ref peError, eApplicationType);
}
internal static extern IntPtr Init(ref EVRInitError peError, EVRApplicationType eApplicationType);
internal static extern IntPtr GetGenericInterface([In, MarshalAs(UnmanagedType.LPStr)] string pchInterfaceVersion, ref EVRInitError peError);
public static CVRSystem Init(ref EVRInitError peError, EVRApplicationType eApplicationType = EVRApplicationType.VRApplication_Scene)
{
OpenVR.VRToken = OpenVR.InitInternal(ref peError, eApplicationType);
OpenVR.OpenVRInternal_ModuleContext.Clear();
if (peError != EVRInitError.None)
{
return null;
}
if (!OpenVR.IsInterfaceVersionValid("IVRSystem_011"))
{
OpenVR.ShutdownInternal();
peError = EVRInitError.Init_InterfaceNotFound;
return null;
}
return OpenVR.System;
}
public static IntPtr GetGenericInterface(string pchInterfaceVersion, ref EVRInitError peError)
{
return OpenVRInterop.GetGenericInterface(pchInterfaceVersion, ref peError);
}
public static uint InitInternal(ref EVRInitError peError, EVRApplicationType eApplicationType)
{
return OpenVRInterop.InitInternal(ref peError, eApplicationType);
}
/** Finds the active installation of vrclient.dll and initializes it */
public static CVRSystem Init(ref EVRInitError peError, EVRApplicationType eApplicationType = EVRApplicationType.VRApplication_Scene)
{
VRToken = InitInternal(ref peError, eApplicationType);
OpenVRInternal_ModuleContext.Clear();
if (peError != EVRInitError.None)
return null;
bool bInterfaceValid = IsInterfaceVersionValid(IVRSystem_Version);
if (!bInterfaceValid)
{
ShutdownInternal();
peError = EVRInitError.Init_InterfaceNotFound;
return null;
}
return OpenVR.System;
}
static void ReportError(EVRInitError error)
{
switch (error)
{
case EVRInitError.None:
break;
case EVRInitError.VendorSpecific_UnableToConnectToOculusRuntime:
Debug.Log("SteamVR Initialization Failed! Make sure device is on, Oculus runtime is installed, and OVRService_*.exe is running.");
break;
case EVRInitError.Init_VRClientDLLNotFound:
Debug.Log("SteamVR drivers not found! They can be installed via Steam under Library > Tools. Visit http://steampowered.com to install Steam.");
break;
case EVRInitError.Driver_RuntimeOutOfDate:
Debug.Log("SteamVR Initialization Failed! Make sure device's runtime is up to date.");
break;
default:
Debug.Log(OpenVR.GetStringForHmdError(error));
break;
}
}
public static string GetStringForHmdError(EVRInitError error)
{
return Marshal.PtrToStringAnsi(OpenVRInterop.GetStringForHmdError(error));
}
internal static extern uint InitInternal(ref EVRInitError peError, EVRApplicationType eApplicationType);
