public bool CreateOverlay() { if (Created) { return(true); } if (OverlayType == OVRLayType.StandardOverlay) { lastError = Director.Overlay.CreateOverlay(Key, Name, ref overlay_handle); } else if (OverlayType == OVRLayType.DashboardOverlay) { lastError = Director.Overlay.CreateDashboardOverlay(Key, Name, ref overlay_handle, ref thumbnail_handle); } bool result = (lastError == EVROverlayError.None); if (result) { Created = true; } if (result && Options != null) { SetOverlayOptions((OVRLayOptions)Options); } return(result); }
public Overlay(string key, string name, Texture tex) { myTexture = tex; myVisible = false; myKey = key; myName = name; EVROverlayError error = OpenVR.Overlay.CreateOverlay(myKey, myName, ref myHandle); if (error != EVROverlayError.None) { throw new Exception(string.Format("Error creating VR Overlay {0}", error)); } error = OpenVR.Overlay.SetOverlayInputMethod(myHandle, VROverlayInputMethod.None); if (error != EVROverlayError.None) { throw new Exception(string.Format("Error setting input method {0}", error)); } setSize(1.5f); setOffsetMatrix(Matrix4.CreateTranslation(new Vector3(0.5f, 0f, -1.0f))); //show the overlay visible = true; }
private void AssertNoError(EVROverlayError error) { if (error == EVROverlayError.None) { return; } throw new OpenVRSystemException <EVROverlayError>($"An error occurred within an Overlay. {error}", error); }
public bool ShowKeyboard(string description = "", string placeHolder = "") { if (!Created) { return(false); } lastError = Director.Overlay.ShowKeyboard(0, 0, description, 256, placeHolder, false, 0); return(lastError == EVROverlayError.None); }
public void SetTexture(ref Texture_t texture) { EVROverlayError err = SteamVR_WebKit.OverlayManager.SetOverlayTexture(_handle, ref texture); if (err != EVROverlayError.None) { Console.WriteLine("Failed to send texture: " + err.ToString()); } }
public bool Show() { if (!Created) { return(false); } lastError = Director.Overlay.ShowOverlay(overlay_handle); return(lastError == EVROverlayError.None); }
public void setSize(float meters) { EVROverlayError error = OpenVR.Overlay.SetOverlayWidthInMeters(myHandle, 1.5f); if (error != EVROverlayError.None) { Warn.print("Error setting overlay width {0}", error); } }
public bool SetTexture(IntPtr TextureHandle) { if (!Created) { return(false); } textureStruct.handle = TextureHandle; lastError = Director.Overlay.SetOverlayTexture(overlay_handle, ref textureStruct); return(lastError == EVROverlayError.None); }
/** * If an overlay error is not None, log it to the console as a warning */ public static bool ReportError(EVROverlayError err) { if (err != EVROverlayError.None) { Debug.LogWarning(OpenVR.Overlay.GetOverlayErrorNameFromEnum(err)); return(false); } return(true); }
public bool SetDashboardIconTexture(IntPtr textureHandle) { if (!Created) { return(false); } dashboardIconStruct.handle = textureHandle; lastError = Director.Overlay.SetOverlayTexture(thumbnail_handle, ref dashboardIconStruct); return(lastError == EVROverlayError.None); }
protected bool ErrorCheck(EVROverlayError error) { bool err = (error != EVROverlayError.None); if (err) { Debug.Log("Error: " + Overlay.GetOverlayErrorNameFromEnum(error)); } return(err); }
/// <summary> /// Checks a <see cref="EVROverlayError"/> for errors /// </summary> /// <param name="error">The error to test</param> /// <returns>Returns false if all good, returns true if there is an actual error</returns> private bool ErrorCheck(EVROverlayError error) { bool err = (error != EVROverlayError.None); if (err) { CLog.Log(OpenVR.Overlay.GetOverlayErrorNameFromEnum(error), CLogLevel.Error); } return(err); }
// Update is called once per frame void Update() { if (DPDesktopOverlay.overlays.Count > 1) { DPDesktopOverlay.overlays[0].overlay._overlayTexture_t.handle = _duplicator.Hwnd; EVROverlayError error = OpenVR.Overlay.SetOverlayTexture(DPDesktopOverlay.overlays[0].overlay.handle, ref DPDesktopOverlay.overlays[0].overlay._overlayTexture_t); Debug.Log(error); } }
public void setOffsetMatrix(Matrix4 mat) { HmdMatrix34_t m = VR.convertToMatrix34(mat); EVROverlayError error = EVROverlayError.None; error = OpenVR.Overlay.SetOverlayTransformTrackedDeviceRelative(myHandle, OpenVR.k_unTrackedDeviceIndex_Hmd, ref m); //error = OpenVR.Overlay.SetOverlayTransformAbsolute(myHandle, ETrackingUniverseOrigin.TrackingUniverseSeated, ref m); if (error != EVROverlayError.None) { Warn.print("Error setting overlay transfrom {0}", error); } }
internal void SetTexture(Texture tex) { if (tex == null) { return; } //if (!CheckValid()) return; /*if (isFirst) { * _currentTexture = tex; * _overlayTexture_t.handle = tex.GetNativeTexturePtr(); * isFirst = false; * * }*/ try { //if (_currentTexture != null && _currentTexture.width != tex.width || _currentTexture.height != tex.height) { // _currentTexture = tex; // _overlayTexture_t.handle = tex.GetNativeTexturePtr(); //} //tex. /*if (_currentTexture != tex || _currentTexture == null) { * _overlayTexture_t.handle = tex.GetNativeTexturePtr(); * * _currentTexture = tex; * }*/ _currentTexture = tex; if (pauseAllTexturePtrs) { return; } _overlayTexture_t.handle = tex.GetNativeTexturePtr(); if (!CheckValid()) { return; } EVROverlayError error = OpenVR.Overlay.SetOverlayTexture(handle, ref _overlayTexture_t); //if (error != EVROverlayError.None) Debug.Log(error); } catch (Exception e) { Debug.LogError(e); } }
/// <summary> /// Set the texture bounds of the overlay, and update it if the overlay is visible. /// </summary> /// <param name="texBounds">The new texture bounds</param> internal void SetTextureBounds(VRTextureBounds_t texBounds) { textureBounds = texBounds; if (!CheckValid()) { return; } error = OpenVR.Overlay.SetOverlayTextureBounds(handle, ref textureBounds); //return ErrorCheck(error); }
public bool DestroyOverlay() { if (!_created || !OverlayExists || !validHandle) { return(true); } error = Overlay.DestroyOverlay(_overlayHandle); _created = false; return(_created); }
/// <summary> /// If the overlay handle is currently valid, it destroys the openvr representation of the overlay. /// </summary> /// <returns>Returns false if the overlay was successfully destroyed</returns> public void DestroyOverlay() { if (!CheckValid()) { return; } if (OpenVR.Overlay != null) { error = OpenVR.Overlay.DestroyOverlay(handle); handle = OpenVR.k_ulOverlayHandleInvalid; } }
// Token: 0x06005F2D RID: 24365 RVA: 0x00215594 File Offset: 0x00213994 private ulong GetOverlayHandle(string overlayName, Transform transform, float widthInMeters = 1f) { ulong num = 0UL; CVROverlay overlay = OpenVR.Overlay; if (overlay == null) { return(num); } string pchOverlayKey = SteamVR_Overlay.key + "." + overlayName; EVROverlayError evroverlayError = overlay.FindOverlay(pchOverlayKey, ref num); if (evroverlayError != EVROverlayError.None) { evroverlayError = overlay.CreateOverlay(pchOverlayKey, overlayName, ref num); } if (evroverlayError == EVROverlayError.None) { overlay.ShowOverlay(num); overlay.SetOverlayAlpha(num, this.alpha); overlay.SetOverlayWidthInMeters(num, widthInMeters); if (SteamVR.instance.textureType == ETextureType.DirectX) { VRTextureBounds_t vrtextureBounds_t = default(VRTextureBounds_t); vrtextureBounds_t.uMin = 0f; vrtextureBounds_t.vMin = 1f; vrtextureBounds_t.uMax = 1f; vrtextureBounds_t.vMax = 0f; overlay.SetOverlayTextureBounds(num, ref vrtextureBounds_t); } SteamVR_Camera steamVR_Camera = (this.loadingScreenDistance != 0f) ? null : SteamVR_Render.Top(); if (steamVR_Camera != null && steamVR_Camera.origin != null) { SteamVR_Utils.RigidTransform rigidTransform = new SteamVR_Utils.RigidTransform(steamVR_Camera.origin, transform); rigidTransform.pos.x = rigidTransform.pos.x / steamVR_Camera.origin.localScale.x; rigidTransform.pos.y = rigidTransform.pos.y / steamVR_Camera.origin.localScale.y; rigidTransform.pos.z = rigidTransform.pos.z / steamVR_Camera.origin.localScale.z; HmdMatrix34_t hmdMatrix34_t = rigidTransform.ToHmdMatrix34(); overlay.SetOverlayTransformAbsolute(num, SteamVR_Render.instance.trackingSpace, ref hmdMatrix34_t); } else { SteamVR_Utils.RigidTransform rigidTransform2 = new SteamVR_Utils.RigidTransform(transform); HmdMatrix34_t hmdMatrix34_t2 = rigidTransform2.ToHmdMatrix34(); overlay.SetOverlayTransformAbsolute(num, SteamVR_Render.instance.trackingSpace, ref hmdMatrix34_t2); } } return(num); }
void SetThumbnailPath(string path) { if (_thumbnailHandle == 0) { throw new Exception("Overlay not initialised"); } EVROverlayError err = EVROverlayError.None; SteamVR_WebKit.OverlayManager.SetOverlayFromFile(_thumbnailHandle, path); if (err != EVROverlayError.None) { throw new Exception("Failed to set thumbnail: " + err.ToString()); } }
private void OnEnable() { CVROverlay overlay = OpenVR.Overlay; if (overlay != null) { EVROverlayError evroverlayError = overlay.CreateOverlay(SteamVR_Overlay.key, base.gameObject.name, ref this.handle); if (evroverlayError != EVROverlayError.None) { Debug.Log(overlay.GetOverlayErrorNameFromEnum(evroverlayError)); base.enabled = false; return; } } SteamVR_Overlay.instance = this; }
public void ShowKeyboard(string value = "") { EVROverlayError err = EVROverlayError.None; if (DashboardOverlay == null && InGameOverlay != null) { err = SteamVR_WebKit.OverlayManager.ShowKeyboardForOverlay(InGameOverlay.Handle, 0, 0, "", 256, value, true, 0); SteamVR_WebKit.OverlayManager.SetKeyboardPositionForOverlay(InGameOverlay.Handle, new HmdRect2_t() { vTopLeft = new HmdVector2_t() { v0 = 0, v1 = _windowHeight }, vBottomRight = new HmdVector2_t() { v0 = _windowWidth, v1 = 0 } }); } else if (DashboardOverlay != null && InGameOverlay == null) { err = SteamVR_WebKit.OverlayManager.ShowKeyboardForOverlay(DashboardOverlay.Handle, 0, 0, "", 256, value, true, 0); SteamVR_WebKit.OverlayManager.SetKeyboardPositionForOverlay(DashboardOverlay.Handle, new HmdRect2_t() { vTopLeft = new HmdVector2_t() { v0 = 0, v1 = _windowHeight }, vBottomRight = new HmdVector2_t() { v0 = _windowWidth, v1 = 0 } }); } else if (DashboardOverlay != null && InGameOverlay != null) { // Maybe use last interacted? } else { err = SteamVR_WebKit.OverlayManager.ShowKeyboard(0, 0, "", 256, value, true, 0); } if (err == EVROverlayError.None) { SteamVR_WebKit.ActiveKeyboardOverlay = this; } }
public bool DestroyOverlay() { if (!Created) { return(true); } lastError = Director.Overlay.DestroyOverlay(overlay_handle); bool result = (lastError == EVROverlayError.None); if (result) { Created = false; } return(result); }
void CreateOverlayInSteamVR() { EVROverlayError ovrErr = EVROverlayError.None; if (SteamVR_WebKit.OverlayManager == null) { SteamVR_WebKit.Init(); } if (_ingame) { ovrErr = SteamVR_WebKit.OverlayManager.CreateOverlay(Key, Name, ref _handle); SteamVR_WebKit.OverlayManager.SetOverlayInputMethod(_handle, VROverlayInputMethod.None); } else { ovrErr = SteamVR_WebKit.OverlayManager.CreateDashboardOverlay(Key, Name, ref _handle, ref _thumbnailHandle); SteamVR_WebKit.OverlayManager.SetOverlayInputMethod(_handle, VROverlayInputMethod.Mouse); SteamVR_WebKit.OverlayManager.SetOverlayFlag(_handle, VROverlayFlags.ShowTouchPadScrollWheel, true); SteamVR_WebKit.OverlayManager.SetOverlayFlag(_handle, VROverlayFlags.SendVRScrollEvents, true); } Console.WriteLine("Overlay Handle " + _handle + ", Thumbnail Handle: " + _thumbnailHandle); if (ovrErr != EVROverlayError.None) { throw new Exception("Failed to create overlay: " + ovrErr.ToString()); } SteamVR_WebKit.OverlayManager.SetOverlayAlpha(_handle, 1.0f); SteamVR_WebKit.OverlayManager.SetOverlayColor(_handle, 1.0f, 1.0f, 1.0f); // Because it'll be upside down otherwise. VRTextureBounds_t bounds; bounds.vMax = 0; bounds.vMin = 1; // Flip the Y // Leave as defaults bounds.uMin = 0; bounds.uMax = 1; SteamVR_WebKit.OverlayManager.SetOverlayTextureBounds(_handle, ref bounds); }
public void SetDeviceAttachment(uint index, Vector3 position, Vector3 rotation) { if (!_ingame) { throw new Exception("Cannot set attachment for dashboard overlay"); } _position = position; _rotation = rotation; HmdMatrix34_t matrix = GetMatrixFromPositionAndRotation(position, rotation); EVROverlayError err = NexHudEngine.OverlayManager.SetOverlayTransformTrackedDeviceRelative(_handle, index, ref matrix); if (err != EVROverlayError.None) { NexHudEngine.Log("Failed to attach " + Key + " to Device " + index + " failed: " + err.ToString()); } }
public void SetTexture(ref Texture_t texture) { EVROverlayError err = NexHudEngine.OverlayManager.SetOverlayTexture(_handle, ref texture); if (err != EVROverlayError.None) { NexHudEngine.Log("Failed to send texture: " + err.ToString()); } if (_hasBackSide) { err = NexHudEngine.OverlayManager.SetOverlayTexture(_backSideHandle, ref texture); if (err != EVROverlayError.None) { NexHudEngine.Log("Failed to send texture: " + err.ToString()); } } }
/// <summary> /// Set the overlay transform in SteamVR /// </summary> /// <param name="newPos">The new position</param> /// <param name="newRot">The new rotation</param> /// <param name="setTarget">Should this be the new target position, or is this temporary?</param> public void SetTransform(Vector3 newPos, Vector3 newRot, bool setTarget = true) { pos = newPos; rot = newRot; if (setTarget) { targetPos = newPos; targetRot = newRot; } matrixConverter.pos = newPos; matrixConverter.rot = Quaternion.Euler(newRot); _overlayTransform = matrixConverter.ToHmdMatrix34(); _overlayTransformAbsoluteTrackingOrigin = SteamVRManager.trackingSpace; if (!CheckValid()) { return; } switch (_overlayTransformType) { default: case VROverlayTransformType.VROverlayTransform_Absolute: error = OpenVR.Overlay.SetOverlayTransformAbsolute(handle, _overlayTransformAbsoluteTrackingOrigin, ref _overlayTransform); break; case VROverlayTransformType.VROverlayTransform_TrackedDeviceRelative: error = OpenVR.Overlay.SetOverlayTransformTrackedDeviceRelative(handle, _overlayTransformTrackedDeviceRelativeIndex, ref _overlayTransform); break; } }
void UpdateModel(string filePath) { HmdColor_t col = new HmdColor_t(); col.a = Opacity; col.r = 1; col.g = 1; col.b = 1; string ModelFilePath = Path.IsPathRooted(filePath) ? filePath : PathUtilities.GetTruePath(_parent.BasePath, filePath); EVROverlayError err = OpenVR.Overlay.SetOverlayRenderModel(_internalOverlay.Handle, ModelFilePath, ref col); if (err != EVROverlayError.None) { Logger.Error("[RENDERMODEL] Failed to set overlay render model: " + err.ToString()); } else { err = OpenVR.Overlay.SetOverlayTexture(_internalOverlay.Handle, ref _onePixelTexture); if (err != EVROverlayError.None) { Logger.Error("[RENDERMODEL] Failed to set overlay render model stub texture: " + err.ToString()); } else if (CurrentAnimation == null) // Don't log if we're animating. { Logger.Info("[RENDERMODEL] Set render model " + ModelFilePath + " and stub texture for " + _parent.DerivedKey + ".models." + Key); } } /*for(uint i = 0; i < OpenVR.RenderModels.GetRenderModelCount(); i++) * { * StringBuilder renderModelName = new StringBuilder(255); * StringBuilder renderModelPath = new StringBuilder(1024); * OpenVR.RenderModels.GetRenderModelName(i, renderModelName, 255); * EVRRenderModelError rerr = EVRRenderModelError.None; * OpenVR.RenderModels.GetRenderModelOriginalPath(renderModelName.ToString().Trim(), renderModelPath, 1024, ref rerr); * * Logger.Trace("Render Model: " + renderModelName.ToString().Trim() + ", path: " + renderModelPath.ToString().Trim() + ", Error: " + rerr.ToString()); * }*/ }
public bool SetOverlayOptions(OVRLayOptions opts) { this.Options = opts; if (!Created) { return(false); } if (opts.Color != null) { lastError = Director.Overlay.SetOverlayColor(overlay_handle, opts.Color[0], opts.Color[1], opts.Color[2]); } if (opts.Alpha != null) { lastError = Director.Overlay.SetOverlayAlpha(overlay_handle, (float)opts.Alpha); } if (opts.WidthInMeters != null) { lastError = Director.Overlay.SetOverlayWidthInMeters(overlay_handle, (float)opts.WidthInMeters); } if (opts.AutoCurveDistanceRangeInMeters != null) { lastError = Director.Overlay.SetOverlayAutoCurveDistanceRangeInMeters( overlay_handle, (float)opts.AutoCurveDistanceRangeInMeters[0], (float)opts.AutoCurveDistanceRangeInMeters[1] ); } if (opts.TextureBounds != null) { var transF = (VRTextureBounds_t)opts.TextureBounds; lastError = Director.Overlay.SetOverlayTextureBounds(overlay_handle, ref transF); } if (opts.MouseScale != null) { var mouseS = (HmdVector2_t)opts.MouseScale; lastError = Director.Overlay.SetOverlayMouseScale(overlay_handle, ref mouseS); } return(lastError == EVROverlayError.None); }
public virtual bool CreateOverlay() { if (!OverlayExists) { return(_created = false); } if (_overlayIsDashboard) { error = Overlay.CreateDashboardOverlay(_overlayKey, _overlayName, ref _overlayHandle, ref _overlayThumbnailHandle); } else { error = Overlay.CreateOverlay(_overlayKey, _overlayName, ref _overlayHandle); } bool allGood = !ErrorCheck(error); return(_created = allGood); }
public abstract string GetOverlayErrorNameFromEnum(EVROverlayError error);
public abstract uint GetOverlayName(ulong ulOverlayHandle,System.Text.StringBuilder pchValue,uint unBufferSize,ref EVROverlayError pError);
internal static extern IntPtr VR_IVROverlay_GetOverlayErrorNameFromEnum(IntPtr instancePtr, EVROverlayError error);
internal static extern uint VR_IVROverlay_GetOverlayName(IntPtr instancePtr, ulong ulOverlayHandle, System.Text.StringBuilder pchValue, uint unBufferSize, ref EVROverlayError pError);
public override string GetOverlayErrorNameFromEnum(EVROverlayError error) { CheckIfUsable(); IntPtr result = VRNativeEntrypoints.VR_IVROverlay_GetOverlayErrorNameFromEnum(m_pVROverlay,error); return (string) Marshal.PtrToStructure(result, typeof(string)); }
public override uint GetOverlayName(ulong ulOverlayHandle,System.Text.StringBuilder pchValue,uint unBufferSize,ref EVROverlayError pError) { CheckIfUsable(); uint result = VRNativeEntrypoints.VR_IVROverlay_GetOverlayName(m_pVROverlay,ulOverlayHandle,pchValue,unBufferSize,ref pError); return result; }
public string GetOverlayErrorNameFromEnum(EVROverlayError error) { IntPtr result = FnTable.GetOverlayErrorNameFromEnum(error); return Marshal.PtrToStringAnsi(result); }
public uint GetOverlayName(ulong ulOverlayHandle,System.Text.StringBuilder pchValue,uint unBufferSize,ref EVROverlayError pError) { uint result = FnTable.GetOverlayName(ulOverlayHandle,pchValue,unBufferSize,ref pError); return result; }
public string GetOverlayErrorNameFromEnum(EVROverlayError error) { IntPtr result = FnTable.GetOverlayErrorNameFromEnum(error); return (string) Marshal.PtrToStructure(result, typeof(string)); }