//OpenVRを初期化する public bool StartOpenVR(EVRApplicationType type = EVRApplicationType.VRApplication_Overlay) { //すでに利用可能な場合は初期化しない(衝突する) if (Init()) { return(true); } //初期化する var openVRError = EVRInitError.None; openvr = OpenVR.Init(ref openVRError, type); if (openVRError != EVRInitError.None) { return(false); } //本ライブラリも初期化 return(Init()); }
static void Main() { var error = EVRInitError.None; var handle = OpenVR.Init(ref error, EVRApplicationType.VRApplication_Background); if (error != EVRInitError.None) { MessageBox.Show($"Could not connect to OpenVR server: {OpenVR.GetStringForHmdError(error)}\n\nPlease make sure an OpenVR server is running (e.g. SteamVR) and try again.", "Fatal Error"); Application.Exit(); return; } OpenVRHandle = handle; Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); new BatteryStatus().Start(); Application.Run(); }
public static object CallSystemFn(SystemFn fn, params object[] args) { var initOpenVR = !Varjo_SteamVR.active; if (initOpenVR) { var error = EVRInitError.None; OpenVR.Init(ref error, EVRApplicationType.VRApplication_Background); } var system = OpenVR.System; var result = (system != null) ? fn(system, args) : null; if (initOpenVR) { OpenVR.Shutdown(); } return(result); }
public static object CallSystemFn(SystemFn fn, params object[] args) { var initOpenVR = (!SteamVR.active && !SteamVR.usingNativeSupport); if (initOpenVR) { var error = EVRInitError.None; OpenVR.Init(ref error, EVRApplicationType.VRApplication_Utility); } var system = OpenVR.System; var result = (system != null) ? fn(system, args) : null; if (initOpenVR) { OpenVR.Shutdown(); } return(result); }
public override int TryInitialize() { var error = EVRInitError.None; m_System = OpenVR.Init(ref error); if (error != EVRInitError.None) { return(-1); } var strDriver = GetTrackedDeviceString(OpenVR.k_unTrackedDeviceIndex_Hmd, ETrackedDeviceProperty.Prop_TrackingSystemName_String); var strDisplay = GetTrackedDeviceString(OpenVR.k_unTrackedDeviceIndex_Hmd, ETrackedDeviceProperty.Prop_SerialNumber_String); Debug.LogFormat("Driver: {0} - Display {1}", strDriver, strDisplay); PreviewRenderEffect = SpriteEffects.FlipVertically; return(0); }
public void Connect() { if (vr != null) { return; } //Initialize OpenVR EVRInitError eError = EVRInitError.None; vr = OpenVR.Init(ref eError, EVRApplicationType.VRApplication_Background); if (eError != EVRInitError.None) { ReportError(eError); OpenVR.Shutdown(); vr = null; Success = false; return; } Success = true; }
public static VRSupport TryInit(Client tclient) { if (!Available()) { return(null); } EVRInitError err = EVRInitError.None; VRSupport vrs = new VRSupport() { TheClient = tclient, VR = OpenVR.Init(ref err) }; if (err != EVRInitError.None) { SysConsole.Output(OutputType.INFO, "VR error: " + err + ": " + OpenVR.GetStringForHmdError(err)); return(null); } vrs.Start(); return(vrs); }
// Initializing connection to OpenVR private static bool InitVR() { var error = EVRInitError.None; OpenVR.Init(ref error, EVRApplicationType.VRApplication_Overlay); if (error != EVRInitError.None) { LogUtils.WriteLineToCache($"Error: OpenVR init failed: {Enum.GetName(typeof(EVRInitError), error)}"); return(false); } else { LogUtils.WriteLineToCache("OpenVR init success"); // Add app manifest and set auto-launch var appKey = "boll7708.openvrstartup"; if (!OpenVR.Applications.IsApplicationInstalled(appKey)) { var manifestError = OpenVR.Applications.AddApplicationManifest(Path.GetFullPath("./app.vrmanifest"), false); if (manifestError == EVRApplicationError.None) { LogUtils.WriteLineToCache("Successfully installed app manifest"); } else { LogUtils.WriteLineToCache($"Error: Failed to add app manifest: {Enum.GetName(typeof(EVRApplicationError), manifestError)}"); } var autolaunchError = OpenVR.Applications.SetApplicationAutoLaunch(appKey, true); if (autolaunchError == EVRApplicationError.None) { LogUtils.WriteLineToCache("Successfully set app to auto launch"); } else { LogUtils.WriteLineToCache($"Error: Failed to turn on auto launch: {Enum.GetName(typeof(EVRApplicationError), autolaunchError)}"); } } return(true); } }
IEnumerator Initialize() { var error = EVRInitError.None; // No need to initialize OpenVR until we have a valid session while (!VarjoPlugin.SessionValid) { yield return(new WaitForSeconds(1.0f)); } OpenVR.Init(ref error, EVRApplicationType.VRApplication_Utility); if (error != EVRInitError.None) { Debug.LogWarning("Failed to initialize OpenVR. Entering into poll mode..."); do { OpenVR.Init(ref error, EVRApplicationType.VRApplication_Utility); yield return(new WaitForSeconds(3.0f)); } while (error != EVRInitError.None); } Debug.Log("Varjo_SteamVR_Manager initialized succesfully"); Varjo_SteamVR_Events.System(EVREventType.VREvent_Quit).Listen(OnQuit); #if UNITY_2017_1_OR_NEWER Application.onBeforeRender += OnBeforeRender; #else Camera.onPreCull += OnCameraPreCull; #endif // We should always use standing tracking with Varjo TrackingSpace = ETrackingUniverseOrigin.TrackingUniverseStanding; var vr = Varjo_SteamVR.instance; if (vr == null) { enabled = false; yield break; } }
private static SteamVR CreateInstance() { try { EVRInitError eVRInitError = EVRInitError.None; if (!SteamVR.usingNativeSupport) { OpenVR.Init(ref eVRInitError, EVRApplicationType.VRApplication_Scene); if (eVRInitError != EVRInitError.None) { SteamVR.ReportError(eVRInitError); SteamVR.ShutdownSystems(); SteamVR result = null; return(result); } } OpenVR.GetGenericInterface("IVRCompositor_013", ref eVRInitError); if (eVRInitError != EVRInitError.None) { SteamVR.ReportError(eVRInitError); SteamVR.ShutdownSystems(); SteamVR result = null; return(result); } OpenVR.GetGenericInterface("IVROverlay_010", ref eVRInitError); if (eVRInitError != EVRInitError.None) { SteamVR.ReportError(eVRInitError); SteamVR.ShutdownSystems(); SteamVR result = null; return(result); } } catch (Exception message) { Debug.LogError(message); SteamVR result = null; return(result); } return(new SteamVR()); }
void Start() { var error = EVRInitError.None; _vrSystem = OpenVR.Init(ref error, EVRApplicationType.VRApplication_Other); if (error != EVRInitError.None) { Debug.LogWarning("Init error: " + error); } else { Debug.Log("init done"); foreach (var item in targetObjs) { item.SetActive(false); } SetDeviceIds(); } }
public static OpenVRScene Create(float nearClip, float farClip) { EVRInitError error = EVRInitError.None; CVRSystem hmd = OpenVR.Init(ref error, EVRApplicationType.VRApplication_Scene); if (error != EVRInitError.None) { throw new InvalidOperationException($"Unable to initilize OpenVR: {error}"); } string[] failedProps = OpenVRUtil.GetFailedRequiredComponents().ToArray(); if (failedProps.Length != 0) { throw new InvalidOperationException($"Failed to initialize the following static properties: {string.Join(", ", failedProps)}"); } int leftIndex = hmd.LeftControllerIndex().Validate(errMsg => new InvalidOperationException(errMsg)); int rightIndex = hmd.RightControllerIndex().Validate(errMsg => new InvalidOperationException(errMsg)); return(new OpenVRScene(nearClip, farClip, hmd, leftIndex, rightIndex)); }
bool OpenVR_Setup() { EVRInitError error = EVRInitError.None; OpenVR.Init(ref error, appType); if (CheckErr(error)) { return(false); } // OpenVR.GetGenericInterface(OpenVR.IVRCompositor_Version, ref error); // if(CheckErr(error)) return false; // OpenVR.GetGenericInterface(OpenVR.IVROverlay_Version, ref error); // if(CheckErr(error)) return false; Debug.Log("OpenVR - Startup!"); return(true); }
public void Initialize(string name, string key, TextureFormat format) { var openVRError = EVRInitError.None; var overlayError = EVROverlayError.None; //OpenVRの初期化 openvr = OpenVR.Init(ref openVRError, EVRApplicationType.VRApplication_Overlay); if (openVRError != EVRInitError.None) { Dispose(); throw new IOException(openVRError.ToString()); } //オーバーレイ機能の初期化 overlay = OpenVR.Overlay; overlayError = overlay.CreateOverlay(name, key, ref overlayHandle); if (overlayError != EVROverlayError.None) { Dispose(); throw new IOException(overlayError.ToString()); } //オーバーレイに渡すテクスチャ種類の設定 if (format == TextureFormat.OpenGL) { //pGLuintTexture overlayTexture.eType = ETextureType.OpenGL; //上下反転しない SetTextureBounds(0, 0, 1, 1); } else { //pTexture overlayTexture.eType = ETextureType.DirectX; //上下反転する SetTextureBounds(0, 1, 1, 0); } return; }
static SteamVR CreateInstance() { try { var error = EVRInitError.None; OpenVR.Init(ref error); if (error != EVRInitError.None) { ReportError(error); ShutdownSystems(); return(null); } // Verify common interfaces are valid. OpenVR.GetGenericInterface(OpenVR.IVRCompositor_Version, ref error); if (error != EVRInitError.None) { ReportError(error); ShutdownSystems(); return(null); } OpenVR.GetGenericInterface(OpenVR.IVROverlay_Version, ref error); if (error != EVRInitError.None) { ReportError(error); ShutdownSystems(); return(null); } } catch (System.Exception e) { throw new System.Exception(e.Message); } return(new SteamVR()); }
protected override void Initialize() { base.Initialize(); var error = EVRInitError.None; bool initialized = true; hmd = OpenVR.Init(ref error); if (error != EVRInitError.None) { ReportError(error); initialized = false; } // Verify common interfaces are valid. OpenVR.GetGenericInterface(OpenVR.IVRCompositor_Version, ref error); if (error != EVRInitError.None) { ReportError(error); initialized = false; } OpenVR.GetGenericInterface(OpenVR.IVROverlay_Version, ref error); if (error != EVRInitError.None) { ReportError(error); initialized = false; } if (!initialized) { OpenVR.Shutdown(); return; } controllerManager.Initialize(); }
public void Init() { this.connectionCode = Properties.Settings.Default.ConnectionCode; if (this.connectionCode == null || this.connectionCode.Length == 0) { this.connectionCode = RandomString(16); Properties.Settings.Default.ConnectionCode = this.connectionCode; Properties.Settings.Default.Save(); } Console.WriteLine("Connection Code: " + this.connectionCode); //var controller = HUDCenterController.GetInstance(); //controller.Init(EVRApplicationType.VRApplication_Overlay); EVRInitError error = EVRInitError.None; OpenVR.Init(ref error, EVRApplicationType.VRApplication_Overlay); 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!"); } InitOverlay(); }
void Start() { var error = EVRInitError.None; _vrSystem = OpenVR.Init(ref error, EVRApplicationType.VRApplication_Other); if (error != EVRInitError.None) { Debug.LogWarning("Init error: " + error); } else { Debug.Log("init done"); foreach (var item in targetObjs) { //Quaternion fixedRot = Quaternion.Euler(90f, 0f, 0f); //item.transform.rotation; item.SetActive(false); } SetDeviceIds(); } }
static SteamVR CreateInstance() { try { var error = 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.Init(ref error, EVRApplicationType.VRApplication_Overlay); // Verify common interfaces are valid. OpenVR.GetGenericInterface(OpenVR.IVRCompositor_Version, ref error); if (error != EVRInitError.None) { ReportError(error); return(null); } OpenVR.GetGenericInterface(OpenVR.IVROverlay_Version, ref error); if (error != EVRInitError.None) { ReportError(error); return(null); } } catch (System.Exception e) { Debug.LogError(e); return(null); } return(new SteamVR()); }
static void RegisterManifest() { EVRInitError initErr = EVRInitError.None; OpenVR.Init(ref initErr, EVRApplicationType.VRApplication_Utility); if (initErr != EVRInitError.None) { Console.WriteLine($"Error initializing OpenVR handle: {initErr}"); Environment.Exit(1); } var err = OpenVR.Applications.AddApplicationManifest(Utils.PathToResource("manifest.vrmanifest"), false); if (err != EVRApplicationError.None) { Console.WriteLine($"Error registering manifest with OpenVR runtime: {err}"); Environment.Exit(1); } Console.WriteLine("Application manifest registered with OpenVR runtime!"); OpenVR.Shutdown(); }
static void DeregisterManifest() { EVRInitError initErr = EVRInitError.None; OpenVR.Init(ref initErr, EVRApplicationType.VRApplication_Utility); if (initErr != EVRInitError.None) { Console.WriteLine($"Error initializing OpenVR handle: {initErr}"); Environment.Exit(1); } var err = OpenVR.Applications.RemoveApplicationManifest(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Resources", "manifest.vrmanifest")); if (err != EVRApplicationError.None) { Console.WriteLine($"Error de-registering manifest with OpenVR runtime: {err}"); Environment.Exit(1); } Console.WriteLine("Application manifest de-registered with OpenVR runtime!"); OpenVR.Shutdown(); }
public bool Init() { EVRInitError peError = EVRInitError.None; m_HMD = OpenVR.Init(ref peError, EVRApplicationType.VRApplication_Overlay); if (peError != EVRInitError.None) { txtLog.AppendText("OpenVR啟動失敗: " + peError + '\n'); return(false); } if (OpenVR.Overlay != null) { EVROverlayError overlayError = OpenVR.Overlay.CreateOverlay("ViveOverlayPaster", "Paster", ref m_ulOverlayHandle); if (overlayError == EVROverlayError.None) { OpenVR.Overlay.SetOverlayWidthInMeters(m_ulOverlayHandle, 1f); OpenVR.Overlay.SetOverlayTransformTrackedDeviceRelative(m_ulOverlayHandle, OpenVR.k_unTrackedDeviceIndex_Hmd, ref m_PosMatrix); OpenVR.Overlay.SetOverlayAlpha(m_ulOverlayHandle, 0.9f); txtLog.AppendText("OpenVR啟動成功\n"); return(true); } } return(false); }
public bool Setup() { var error = EVRInitError.None; openVR = OpenVR.Init(ref error, EVRApplicationType.VRApplication_Overlay); if (error == EVRInitError.Init_HmdNotFound) { Close(); //HMD require fallback openVR = OpenVR.Init(ref error, EVRApplicationType.VRApplication_Background); } if (error != EVRInitError.None) { //Error Init OpenVR Close(); System.IO.File.WriteAllText(Application.dataPath + "/../OpenVRInitError.txt", error.ToString()); return(false); } OnOVRConnected?.Invoke(this, new OVRConnectedEventArgs(true)); return(true); }
/// <summary> /// Initialize HMD using OpenVR API calls. /// </summary> /// <returns>True on successful initialization, false otherwise.</returns> private static void InitializeOpenVR() { // return if HMD has already been initialized if (hmdState == HmdState.Initialized) { return; } // set the location of the OpenVR DLL SetDllDirectory(Globals.OpenVRDllPath); // check if HMD is connected on the system if (!OpenVR.IsHmdPresent()) { throw new InvalidOperationException("HMD not found on this system"); } // check if SteamVR runtime is installed if (!OpenVR.IsRuntimeInstalled()) { throw new InvalidOperationException("SteamVR runtime not found on this system"); } // initialize HMD EVRInitError hmdInitErrorCode = EVRInitError.None; OpenVR.Init(ref hmdInitErrorCode, EVRApplicationType.VRApplication_Scene); if (hmdInitErrorCode != EVRInitError.None) { throw new Exception("OpenVR error: " + OpenVR.GetStringForHmdError(hmdInitErrorCode)); } // reset "seated position" and capture initial position. this means you should hold the HMD in // the position you would like to consider "seated", before running this code. ResetInitialHmdPosition(); // get HMD render target size uint renderTextureWidth = 0; uint renderTextureHeight = 0; OpenVR.System.GetRecommendedRenderTargetSize(ref renderTextureWidth, ref renderTextureHeight); // at the moment, only Direct3D12 is working with Kerbal Space Program ETextureType textureType = ETextureType.DirectX; switch (SystemInfo.graphicsDeviceType) { case UnityEngine.Rendering.GraphicsDeviceType.OpenGLCore: case UnityEngine.Rendering.GraphicsDeviceType.OpenGLES2: case UnityEngine.Rendering.GraphicsDeviceType.OpenGLES3: textureType = ETextureType.OpenGL; throw new InvalidOperationException(SystemInfo.graphicsDeviceType.ToString() + " does not support VR. You must use -force-d3d12"); case UnityEngine.Rendering.GraphicsDeviceType.Direct3D9: throw new InvalidOperationException(SystemInfo.graphicsDeviceType.ToString() + " does not support VR. You must use -force-d3d12"); case UnityEngine.Rendering.GraphicsDeviceType.Direct3D11: textureType = ETextureType.DirectX; break; case UnityEngine.Rendering.GraphicsDeviceType.Direct3D12: textureType = ETextureType.DirectX; break; default: throw new InvalidOperationException(SystemInfo.graphicsDeviceType.ToString() + " not supported"); } // initialize render textures (for displaying on HMD) for (int i = 0; i < 2; i++) { hmdEyeRenderTexture[i] = new RenderTexture((int)renderTextureWidth, (int)renderTextureHeight, 24, RenderTextureFormat.ARGB32); hmdEyeRenderTexture[i].Create(); hmdEyeTexture[i].handle = hmdEyeRenderTexture[i].GetNativeTexturePtr(); hmdEyeTexture[i].eColorSpace = EColorSpace.Auto; hmdEyeTexture[i].eType = textureType; } // set rendering bounds on texture to render hmdTextureBounds.uMin = 0.0f; hmdTextureBounds.uMax = 1.0f; hmdTextureBounds.vMin = 1.0f; // flip the vertical coordinate for some reason hmdTextureBounds.vMax = 0.0f; }
static RenderModel LoadRenderModel(string renderModelName) { var error = HmdError.None; if (!SteamVR.active) { OpenVR.Init(ref error); if (error != HmdError.None) { return(null); } } var pRenderModels = OpenVR.GetGenericInterface(OpenVR.IVRRenderModels_Version, ref error); if (pRenderModels == System.IntPtr.Zero || error != HmdError.None) { if (!SteamVR.active) { OpenVR.Shutdown(); } return(null); } var renderModels = new CVRRenderModels(pRenderModels); var renderModel = new RenderModel_t(); if (!renderModels.LoadRenderModel(renderModelName, ref renderModel)) { Debug.LogError("Failed to load render model " + renderModelName); if (!SteamVR.active) { OpenVR.Shutdown(); } return(null); } var vertices = new Vector3[renderModel.unVertexCount]; var normals = new Vector3[renderModel.unVertexCount]; var uv = new Vector2[renderModel.unVertexCount]; var type = typeof(RenderModel_Vertex_t); for (int iVert = 0; iVert < renderModel.unVertexCount; iVert++) { var ptr = new System.IntPtr(renderModel.rVertexData.ToInt64() + iVert * Marshal.SizeOf(type)); var vert = (RenderModel_Vertex_t)Marshal.PtrToStructure(ptr, type); vertices[iVert] = new Vector3(vert.vPosition.v[0], vert.vPosition.v[1], -vert.vPosition.v[2]); normals[iVert] = new Vector3(vert.vNormal.v[0], vert.vNormal.v[1], -vert.vNormal.v[2]); uv[iVert] = new Vector2(vert.rfTextureCoord[0], vert.rfTextureCoord[1]); } int indexCount = (int)renderModel.unTriangleCount * 3; var indices = new short[indexCount]; Marshal.Copy(renderModel.rIndexData, indices, 0, indices.Length); var triangles = new int[indexCount]; for (int iTri = 0; iTri < renderModel.unTriangleCount; iTri++) { triangles[iTri * 3 + 0] = (int)indices[iTri * 3 + 2]; triangles[iTri * 3 + 1] = (int)indices[iTri * 3 + 1]; triangles[iTri * 3 + 2] = (int)indices[iTri * 3 + 0]; } var mesh = new Mesh(); mesh.vertices = vertices; mesh.normals = normals; mesh.uv = uv; mesh.triangles = triangles; mesh.Optimize(); //mesh.hideFlags = HideFlags.DontUnloadUnusedAsset; var textureMapData = new byte[renderModel.diffuseTexture.unWidth * renderModel.diffuseTexture.unHeight * 4]; // RGBA Marshal.Copy(renderModel.diffuseTexture.rubTextureMapData, textureMapData, 0, textureMapData.Length); var colors = new Color32[renderModel.diffuseTexture.unWidth * renderModel.diffuseTexture.unHeight]; int iColor = 0; for (int iHeight = 0; iHeight < renderModel.diffuseTexture.unHeight; iHeight++) { for (int iWidth = 0; iWidth < renderModel.diffuseTexture.unWidth; iWidth++) { var r = textureMapData[iColor++]; var g = textureMapData[iColor++]; var b = textureMapData[iColor++]; var a = textureMapData[iColor++]; colors[iHeight * renderModel.diffuseTexture.unWidth + iWidth] = new Color32(r, g, b, a); } } var texture = new Texture2D(renderModel.diffuseTexture.unWidth, renderModel.diffuseTexture.unHeight, TextureFormat.ARGB32, true); texture.SetPixels32(colors); texture.Apply(); //texture.hideFlags = HideFlags.DontUnloadUnusedAsset; renderModels.FreeRenderModel(ref renderModel); if (!SteamVR.active) { OpenVR.Shutdown(); } return(new RenderModel(mesh, texture)); }
static void Main(string[] args) { // Initializing connection to OpenVR var error = EVRInitError.None; OpenVR.Init(ref error, EVRApplicationType.VRApplication_Overlay); if (error != EVRInitError.None) { Utils.PrintError($"OpenVR initialization errored: {Enum.GetName(typeof(EVRInitError), error)}"); } else { Utils.PrintInfo("OpenVR initialized successfully."); // Loading manifests var appError = OpenVR.Applications.AddApplicationManifest(Path.GetFullPath("./app.vrmanifest"), false); if (appError != EVRApplicationError.None) { Utils.PrintError($"Failed to load Application Manifest: {Enum.GetName(typeof(EVRApplicationError), appError)}"); } else { Utils.PrintInfo("Application Manifest loaded successfully."); } var ioErr = OpenVR.Input.SetActionManifestPath(Path.GetFullPath("./actions.json")); if (ioErr != EVRInputError.None) { Utils.PrintError($"Failed to load Action Manifest: {Enum.GetName(typeof(EVRInputError), ioErr)}"); } else { Utils.PrintInfo("Action Manifest loaded successfully."); } // Getting action set handle var errorAS = OpenVR.Input.GetActionSetHandle("actions/default", ref mActionSetHandle); if (errorAS != EVRInputError.None) { Utils.PrintError($"GetActionSetHandle Error: {Enum.GetName(typeof(EVRInputError), errorAS)}"); } Utils.PrintDebug($"Action Set Handle: {mActionSetHandle}"); // Getting action handle. var errorA = OpenVR.Input.GetActionHandle("/actions/default/in/toggle_menu", ref mActionHandle); if (errorA != EVRInputError.None) { Utils.PrintError($"GetActionHandle Error: {Enum.GetName(typeof(EVRInputError), errorA)}"); } Utils.PrintDebug($"Action Handle: {mActionHandle}"); // Starting worker Utils.PrintDebug("Starting worker thread."); var t = new Thread(Worker); if (!t.IsAlive) { t.Start(); } else { Utils.PrintError("Could not start worker thread."); } } Console.ReadLine(); OpenVR.Shutdown(); }
// NOTE // 메모리 릭 때문에 미리 생성해놓고 계속 사용함 public static void Init() { m_Device = new Device(DriverType.Hardware, DeviceCreationFlags.SingleThreaded | DeviceCreationFlags.BgraSupport); m_Texture1 = new Texture2D(m_Device, new Texture2DDescription() { Width = 512, Height = 512, MipLevels = 1, ArraySize = 1, Format = Format.B8G8R8A8_UNorm, SampleDescription = new SampleDescription(1, 0), Usage = ResourceUsage.Dynamic, BindFlags = BindFlags.ShaderResource, CpuAccessFlags = CpuAccessFlags.Write }); m_Texture2 = new Texture2D(m_Device, new Texture2DDescription() { Width = 512, Height = 512, MipLevels = 1, ArraySize = 1, Format = Format.B8G8R8A8_UNorm, SampleDescription = new SampleDescription(1, 0), Usage = ResourceUsage.Dynamic, BindFlags = BindFlags.ShaderResource, CpuAccessFlags = CpuAccessFlags.Write }); m_Browser1 = new Browser(m_Texture1, Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "html/vr.html?1")); m_Browser2 = new Browser(m_Texture2, Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "html/vr.html?2")); m_Thread = new Thread(() => { var active = false; var e = new VREvent_t(); var nextInit = DateTime.MinValue; var nextDeviceUpdate = DateTime.MinValue; var nextOverlay = DateTime.MinValue; var overlayIndex = OpenVR.k_unTrackedDeviceIndexInvalid; var overlayVisible1 = false; var overlayVisible2 = false; var dashboardHandle = 0UL; var overlayHandle1 = 0UL; var overlayHandle2 = 0UL; while (m_Thread != null) { try { Thread.Sleep(10); } catch { // ThreadInterruptedException } if (m_Active) { m_Browser1.Render(); m_Browser2.Render(); var system = OpenVR.System; if (system == null) { if (DateTime.UtcNow.CompareTo(nextInit) <= 0) { continue; } var _err = EVRInitError.None; system = OpenVR.Init(ref _err, EVRApplicationType.VRApplication_Overlay); nextInit = DateTime.UtcNow.AddSeconds(5); if (system == null) { continue; } active = true; } while (system.PollNextEvent(ref e, (uint)Marshal.SizeOf(e))) { var type = (EVREventType)e.eventType; if (type == EVREventType.VREvent_Quit) { active = false; OpenVR.Shutdown(); nextInit = DateTime.UtcNow.AddSeconds(10); system = null; break; } } if (system != null) { if (DateTime.UtcNow.CompareTo(nextDeviceUpdate) >= 0) { overlayIndex = OpenVR.k_unTrackedDeviceIndexInvalid; UpdateDevices(system, ref overlayIndex); if (overlayIndex != OpenVR.k_unTrackedDeviceIndexInvalid) { nextOverlay = DateTime.UtcNow.AddSeconds(10); } nextDeviceUpdate = DateTime.UtcNow.AddSeconds(0.1); } var overlay = OpenVR.Overlay; if (overlay != null) { var dashboardVisible = overlay.IsDashboardVisible(); var err = ProcessDashboard(overlay, ref dashboardHandle, dashboardVisible); if (err != EVROverlayError.None && dashboardHandle != 0) { overlay.DestroyOverlay(dashboardHandle); dashboardHandle = 0; } err = ProcessOverlay1(overlay, ref overlayHandle1, ref overlayVisible1, dashboardVisible, overlayIndex, nextOverlay); if (err != EVROverlayError.None && overlayHandle1 != 0) { overlay.DestroyOverlay(overlayHandle1); overlayHandle1 = 0; } err = ProcessOverlay2(overlay, ref overlayHandle2, ref overlayVisible2, dashboardVisible); if (err != EVROverlayError.None && overlayHandle2 != 0) { overlay.DestroyOverlay(overlayHandle2); overlayHandle2 = 0; } } } } else if (active) { active = false; OpenVR.Shutdown(); m_Lock.EnterWriteLock(); try { m_Devices.Clear(); } finally { m_Lock.ExitWriteLock(); } } } }) { IsBackground = true }; m_Thread.Start(); }
public bool init() { // Set up HMD EVRInitError eError = EVRInitError.None; mHMD = OpenVR.Init(ref eError, EVRApplicationType.VRApplication_Scene); if (eError == EVRInitError.None) { Rhino.RhinoApp.WriteLine("Booted VR System"); renderPoseArray = new TrackedDevicePose_t[Valve.VR.OpenVR.k_unMaxTrackedDeviceCount]; gamePoseArray = new TrackedDevicePose_t[Valve.VR.OpenVR.k_unMaxTrackedDeviceCount]; } else { Rhino.RhinoApp.WriteLine("Failed to boot"); mTitleBase = "SparrowHawk (No VR Detected)"; } // // THIS IS FOR UNCLIPPED // Width = 864; // Height = 820; // THIS IS FOR CLIPPED RECTANGLE Width = 691; Height = 692; // Window Setup Info mStrDriver = UtilOld.GetTrackedDeviceString(ref mHMD, OpenVR.k_unTrackedDeviceIndex_Hmd, ETrackedDeviceProperty.Prop_TrackingSystemName_String); mStrDisplay = UtilOld.GetTrackedDeviceString(ref mHMD, OpenVR.k_unTrackedDeviceIndex_Hmd, ETrackedDeviceProperty.Prop_SerialNumber_String); mTitleBase = "SparrowHawk - " + mStrDriver + " " + mStrDisplay; Title = mTitleBase; MakeCurrent(); setupScene(); if (eError == EVRInitError.None) { mRenderer = new VrRenderer(ref mHMD, ref mScene, mRenderWidth, mRenderHeight); } else { mRenderer = new VrRenderer(ref mHMD, ref mScene, mRenderWidth, mRenderHeight); } //use other 8 points for calibrartion robotCallibrationPointsTest.Add(new Vector3(22, 15, -100) / 1000); robotCallibrationPointsTest.Add(new Vector3(-10, 40, -153) / 1000); robotCallibrationPointsTest.Add(new Vector3(25, -25, -181) / 1000); foreach (Vector3 v in robotCallibrationPointsTest) { Vector4 v4 = new Vector4(v.X, v.Y, v.Z, 1); v4 = mScene.vrToRobot.Inverted() * v4; UtilOld.MarkPoint(ref mScene.staticGeometry, new Vector3(v4.X, v4.Y, v4.Z), 1, 1, 1); } robotCallibrationPointsTest.Clear(); //set default matrix if (mRenderer.ovrvision_controller != null) { mRenderer.ovrvision_controller.setDefaultMatrixHC(); } //detecting whether users in control or left Rhino.DocObjects.ObjectAttributes attr = new Rhino.DocObjects.ObjectAttributes(); attr.Name = "user:out"; Point3d userP = new Point3d(0, 0, 0); uGuid = mScene.rhinoDoc.Objects.AddPoint(userP, attr); //testing - rotate rhino object as well /* * Transform transM = new Transform(); * for (int row = 0; row < 4; row++) * { * for (int col = 0; col < 4; col++) * { * transM[row, col] = mScene.platformRotation[row, col]; * } * } * Rhino.DocObjects.ObjectEnumeratorSettings settings = new Rhino.DocObjects.ObjectEnumeratorSettings(); * settings.ObjectTypeFilter = Rhino.DocObjects.ObjectType.Brep; * foreach (Rhino.DocObjects.RhinoObject rhObj in mScene.rhinoDoc.Objects.GetObjectList(settings)) * { * mDoc.Objects.Transform(rhObj.Id, transM, true); * } * mScene.rhinoDoc.Views.Redraw(); */ //testing visualize printStroke printStroke = new Geometry.RobotPrintStroke(ref mScene); printStroke_m = new Material.SingleColorMaterial(1, 1, 0, 1.0f); return(eError == EVRInitError.None); }
void KeepAlive() { KeepAliveCounter++; if (StopRequested) { Stop(); return; } if (VRSys == null) { if (KeepAliveCounter % InitializationDivider != 0) // do not attempt initialization on every loop. { return; } // ***** INITIALIZATION ****** //if (!OpenVR.IsHmdPresent()) // Note that this also leaks memory // To avoid a memory leak, check that SteamVR is running before trying to Initialize if (System.Diagnostics.Process.GetProcessesByName(Config.SteamVRProcessName).Any()) { if (InitAttemptCount >= InitAttemptLimit) { Stop(true); // no point to keep looping and eating memory forever } InitAttemptCount++; OpenVRConnStatus = OpenVRConnectionStatus.Initializing; // do not carelessly call OpenVR.Init(), it will leak memory VRSys = OpenVR.Init(ref LastOpenVRError, EVRApplicationType.VRApplication_Background); if (LastOpenVRError != EVRInitError.None || VRSys == null) { if (LastOpenVRError == EVRInitError.Init_HmdNotFound || LastOpenVRError == EVRInitError.Init_HmdNotFoundPresenceFailed) { OpenVRConnStatus = OpenVRConnectionStatus.NoHMD; Thread.Sleep(SleepTimeAfterQuit); } return; } bool hmdFound = false; // check devices and find HMD index (but I suppose it's always 0) - Documentation is vague. // For example, what's the purpose of OpenVR.k_unTrackedDeviceIndex_Hmd? What about multiple HMDs... for (uint i = 0; i < OpenVR.k_unMaxTrackedDeviceCount; i++) { if (VRSys.IsTrackedDeviceConnected(i)) { ETrackedDeviceClass c = VRSys.GetTrackedDeviceClass(i); if (c == ETrackedDeviceClass.HMD) { HmdIndex = i; hmdFound = true; break; } } } if (!hmdFound) { EndCurrentSession(); OpenVRConnStatus = OpenVRConnectionStatus.NoHMD; Thread.Sleep(SleepTimeAfterQuit); return; } PoseArray = new TrackedDevicePose_t[HmdIndex + 1]; for (int i = 0; i < PoseArray.Length; i++) { PoseArray[i] = new TrackedDevicePose_t(); } if (SteamVRWasOffBefore) { // Wait a bit more before reporting OK and allowing hmd queries when SteamVR is started AFTER CG. // The initial yaw values from the API sometimes threw the counter off by one half-turn. // Maybe there's a small window at the beginning when the headset readings are not stable... // This is very hard to reproduce/test as it happens so rarely. Shooting in the dark here. Thread.Sleep(3000); SteamVRWasOffBefore = false; } else { Thread.Sleep(500); } OpenVRConnStatus = OpenVRConnectionStatus.AllOK; } else { SteamVRWasOffBefore = true; OpenVRConnStatus = OpenVRConnectionStatus.NoSteamVR; } } else // VRSys != null (connection has been initialized) { // Check quit request VRSys.PollNextEvent(ref NextVREvent, (uint)System.Runtime.InteropServices.Marshal.SizeOf(NextVREvent)); // this doesn't always work... I suppose the quit event can fly by when the poll rate is relatively low // It seems that SteamVR kills the VR processes that don't get Quit event with PollNextEvent(). if (NextVREvent.eventType == (uint)EVREventType.VREvent_Quit) { OpenVRConnStatus = OpenVRConnectionStatus.SteamVRQuit; // to immediately prevent native methods from being called EndCurrentSession(); OpenVRConnStatus = OpenVRConnectionStatus.SteamVRQuit; // again to get correct status (changed in EndCurrentSession()) // a good sleep before starting to poll steamvr -process again Thread.Sleep(SleepTimeAfterQuit); } else { bool interaction = (VRSys.GetTrackedDeviceActivityLevel(HmdIndex) == EDeviceActivityLevel.k_EDeviceActivityLevel_UserInteraction); if (interaction == HMDUserInteraction_previousReading) { HMDUserInteractionCounter++; } else { HMDUserInteractionCounter = 0; } HMDUserInteraction_previousReading = interaction; // some buffer to filter out false flags (and conveniently some delay for notifications) // ... although false flags are not really possible the way OpenVR currently works if (HMDUserInteractionCounter > HMDUserInteractionDivider) { if (HMDUserInteraction_buffered != interaction) { HMDUserInteraction_buffered = interaction; if (interaction) { Worker.ReportProgress(1, null); } else { Worker.ReportProgress(2, null); } } HMDUserInteractionCounter = 0; } } } }
private void setup() { //init VR System and check for errors var error = EVRInitError.None; vrSystem = OpenVR.Init(ref error, EVRApplicationType.VRApplication_Scene); if ((int)error != (int)EVRInitError.None) { log("KerbalVrPlugin started."); } else { err(error.ToString()); } //rendervalues ######################################################### // Setup render values uint w = 0, h = 0; vrSystem.GetRecommendedRenderTargetSize(ref w, ref h); float sceneWidth = (float)w; float sceneHeight = (float)h; float l_left = 0.0f, l_right = 0.0f, l_top = 0.0f, l_bottom = 0.0f; vrSystem.GetProjectionRaw(EVREye.Eye_Left, ref l_left, ref l_right, ref l_top, ref l_bottom); float r_left = 0.0f, r_right = 0.0f, r_top = 0.0f, r_bottom = 0.0f; vrSystem.GetProjectionRaw(EVREye.Eye_Right, ref r_left, ref r_right, ref r_top, ref r_bottom); Vector2 tanHalfFov = new Vector2(Mathf.Max(-l_left, l_right, -r_left, r_right), Mathf.Max(-l_top, l_bottom, -r_top, r_bottom)); //Setup rendertextures hmdLeftEyeTexture = new Texture_t(); hmdLeftEyeTexture.eColorSpace = EColorSpace.Auto; hmdRightEyeTexture = new Texture_t(); hmdRightEyeTexture.eColorSpace = EColorSpace.Auto; //select Texture Type depending on RenderAPI (Currently only DirectX11 is tested) switch (SystemInfo.graphicsDeviceType) { case UnityEngine.Rendering.GraphicsDeviceType.OpenGL2: log("OpenGL2"); hmdLeftEyeTexture.eType = ETextureType.OpenGL; hmdRightEyeTexture.eType = ETextureType.OpenGL; break; case UnityEngine.Rendering.GraphicsDeviceType.OpenGLCore: log("OpenCore"); hmdLeftEyeTexture.eType = ETextureType.OpenGL; hmdRightEyeTexture.eType = ETextureType.OpenGL; break; case UnityEngine.Rendering.GraphicsDeviceType.OpenGLES2: log("OpenGLES2"); hmdLeftEyeTexture.eType = ETextureType.OpenGL; hmdRightEyeTexture.eType = ETextureType.OpenGL; break; case UnityEngine.Rendering.GraphicsDeviceType.OpenGLES3: log("OpenGLES3"); hmdLeftEyeTexture.eType = ETextureType.OpenGL; hmdRightEyeTexture.eType = ETextureType.OpenGL; break; case UnityEngine.Rendering.GraphicsDeviceType.Direct3D9: log("Direct3D9"); warn("DirectX 9 mode not Supported! There be Dragons!"); hmdLeftEyeTexture.eType = ETextureType.DirectX; hmdRightEyeTexture.eType = ETextureType.DirectX; break; case UnityEngine.Rendering.GraphicsDeviceType.Direct3D11: log("Direct3D11"); hmdLeftEyeTexture.eType = ETextureType.DirectX; hmdRightEyeTexture.eType = ETextureType.DirectX; break; case UnityEngine.Rendering.GraphicsDeviceType.Direct3D12: log("Direct3D12"); warn("DirectX 12 mode not implemented! There be Dragons!"); hmdLeftEyeTexture.eType = ETextureType.DirectX12; hmdRightEyeTexture.eType = ETextureType.DirectX12; break; default: throw (new Exception(SystemInfo.graphicsDeviceType.ToString() + " not supported")); } vrCompositor = OpenVR.Compositor; if (!vrCompositor.CanRenderScene()) { err("can not render scene"); } }