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));
}
