// Token: 0x06000089 RID: 137 RVA: 0x0000658C File Offset: 0x0000478C
private ulong GetOverlayHandle(string overlayName, global::UnityEngine.Transform transform, float widthInMeters = 1f)
{
ulong num = 0UL;
global::Valve.VR.CVROverlay overlay = global::Valve.VR.OpenVR.Overlay;
bool flag = overlay == null;
ulong result;
if (flag)
{
result = num;
}
else
{
string pchOverlayKey = global::SteamVR_Overlay.key + "." + overlayName;
global::Valve.VR.EVROverlayError evroverlayError = overlay.FindOverlay(pchOverlayKey, ref num);
bool flag2 = evroverlayError > global::Valve.VR.EVROverlayError.None;
if (flag2)
{
evroverlayError = overlay.CreateOverlay(pchOverlayKey, overlayName, ref num);
}
bool flag3 = evroverlayError == global::Valve.VR.EVROverlayError.None;
if (flag3)
{
overlay.ShowOverlay(num);
overlay.SetOverlayAlpha(num, this.alpha);
overlay.SetOverlayWidthInMeters(num, widthInMeters);
bool flag4 = global::SteamVR.instance.graphicsAPI == global::Valve.VR.EGraphicsAPIConvention.API_DirectX;
if (flag4)
{
global::Valve.VR.VRTextureBounds_t vrtextureBounds_t = default(global::Valve.VR.VRTextureBounds_t);
vrtextureBounds_t.uMin = 0f;
vrtextureBounds_t.vMin = 1f;
vrtextureBounds_t.uMax = 1f;
vrtextureBounds_t.vMax = 0f;
overlay.SetOverlayTextureBounds(num, ref vrtextureBounds_t);
}
global::SteamVR_Camera steamVR_Camera = (this.loadingScreenDistance == 0f) ? global::SteamVR_Render.Top() : null;
bool flag5 = steamVR_Camera != null && steamVR_Camera.origin != null;
if (flag5)
{
global::SteamVR_Utils.RigidTransform rigidTransform = new global::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;
global::Valve.VR.HmdMatrix34_t hmdMatrix34_t = rigidTransform.ToHmdMatrix34();
overlay.SetOverlayTransformAbsolute(num, global::SteamVR_Render.instance.trackingSpace, ref hmdMatrix34_t);
}
else
{
global::Valve.VR.HmdMatrix34_t hmdMatrix34_t2 = new global::SteamVR_Utils.RigidTransform(transform).ToHmdMatrix34();
overlay.SetOverlayTransformAbsolute(num, global::SteamVR_Render.instance.trackingSpace, ref hmdMatrix34_t2);
}
}
result = num;
}
return(result);
}
// Token: 0x06000086 RID: 134 RVA: 0x000062DC File Offset: 0x000044DC
private void OnGUI()
{
bool flag = global::SteamVR_LoadLevel._active != this;
if (!flag)
{
bool flag2 = this.progressBarEmpty != null && this.progressBarFull != null;
if (flag2)
{
bool flag3 = this.progressBarOverlayHandle == 0UL;
if (flag3)
{
this.progressBarOverlayHandle = this.GetOverlayHandle("progressBar", (this.progressBarTransform != null) ? this.progressBarTransform : base.transform, this.progressBarWidthInMeters);
}
bool flag4 = this.progressBarOverlayHandle > 0UL;
if (flag4)
{
float num = (this.async != null) ? this.async.progress : 0f;
int width = this.progressBarFull.width;
int height = this.progressBarFull.height;
bool flag5 = this.renderTexture == null;
if (flag5)
{
this.renderTexture = new global::UnityEngine.RenderTexture(width, height, 0);
this.renderTexture.Create();
}
global::UnityEngine.RenderTexture active = global::UnityEngine.RenderTexture.active;
global::UnityEngine.RenderTexture.active = this.renderTexture;
bool flag6 = global::UnityEngine.Event.current.type == 7;
if (flag6)
{
global::UnityEngine.GL.Clear(false, true, global::UnityEngine.Color.clear);
}
global::UnityEngine.GUILayout.BeginArea(new global::UnityEngine.Rect(0f, 0f, (float)width, (float)height));
global::UnityEngine.GUI.DrawTexture(new global::UnityEngine.Rect(0f, 0f, (float)width, (float)height), this.progressBarEmpty);
global::UnityEngine.GUI.DrawTextureWithTexCoords(new global::UnityEngine.Rect(0f, 0f, num * (float)width, (float)height), this.progressBarFull, new global::UnityEngine.Rect(0f, 0f, num, 1f));
global::UnityEngine.GUILayout.EndArea();
global::UnityEngine.RenderTexture.active = active;
global::Valve.VR.CVROverlay overlay = global::Valve.VR.OpenVR.Overlay;
bool flag7 = overlay != null;
if (flag7)
{
global::Valve.VR.Texture_t texture_t = default(global::Valve.VR.Texture_t);
texture_t.handle = this.renderTexture.GetNativeTexturePtr();
texture_t.eType = global::SteamVR.instance.graphicsAPI;
texture_t.eColorSpace = global::Valve.VR.EColorSpace.Auto;
overlay.SetOverlayTexture(this.progressBarOverlayHandle, ref texture_t);
}
}
}
}
}
// Token: 0x0600009C RID: 156 RVA: 0x00007390 File Offset: 0x00005590
private void OnDisable()
{
bool flag = this.handle > 0UL;
if (flag)
{
global::Valve.VR.CVROverlay overlay = global::Valve.VR.OpenVR.Overlay;
bool flag2 = overlay != null;
if (flag2)
{
overlay.DestroyOverlay(this.handle);
}
this.handle = 0UL;
}
global::SteamVR_Overlay.instance = null;
}
// Token: 0x0600009E RID: 158 RVA: 0x00007744 File Offset: 0x00005944
public bool PollNextEvent(ref global::Valve.VR.VREvent_t pEvent)
{
global::Valve.VR.CVROverlay overlay = global::Valve.VR.OpenVR.Overlay;
bool flag = overlay == null;
bool result;
if (flag)
{
result = false;
}
else
{
uint uncbVREvent = (uint)global::System.Runtime.InteropServices.Marshal.SizeOf(typeof(global::Valve.VR.VREvent_t));
result = overlay.PollNextOverlayEvent(this.handle, ref pEvent, uncbVREvent);
}
return(result);
}
// Token: 0x0600009B RID: 155 RVA: 0x0000732C File Offset: 0x0000552C
private void OnEnable()
{
global::Valve.VR.CVROverlay overlay = global::Valve.VR.OpenVR.Overlay;
bool flag = overlay != null;
if (flag)
{
global::Valve.VR.EVROverlayError evroverlayError = overlay.CreateOverlay(global::SteamVR_Overlay.key, base.gameObject.name, ref this.handle);
bool flag2 = evroverlayError > global::Valve.VR.EVROverlayError.None;
if (flag2)
{
global::UnityEngine.Debug.Log(overlay.GetOverlayErrorNameFromEnum(evroverlayError));
base.enabled = false;
return;
}
}
global::SteamVR_Overlay.instance = this;
}
// Token: 0x0600009F RID: 159 RVA: 0x00007788 File Offset: 0x00005988
public bool ComputeIntersection(global::UnityEngine.Vector3 source, global::UnityEngine.Vector3 direction, ref global::SteamVR_Overlay.IntersectionResults results)
{
global::Valve.VR.CVROverlay overlay = global::Valve.VR.OpenVR.Overlay;
bool flag = overlay == null;
bool result;
if (flag)
{
result = false;
}
else
{
global::Valve.VR.VROverlayIntersectionParams_t vroverlayIntersectionParams_t = default(global::Valve.VR.VROverlayIntersectionParams_t);
vroverlayIntersectionParams_t.eOrigin = global::SteamVR_Render.instance.trackingSpace;
vroverlayIntersectionParams_t.vSource.v0 = source.x;
vroverlayIntersectionParams_t.vSource.v1 = source.y;
vroverlayIntersectionParams_t.vSource.v2 = -source.z;
vroverlayIntersectionParams_t.vDirection.v0 = direction.x;
vroverlayIntersectionParams_t.vDirection.v1 = direction.y;
vroverlayIntersectionParams_t.vDirection.v2 = -direction.z;
global::Valve.VR.VROverlayIntersectionResults_t vroverlayIntersectionResults_t = default(global::Valve.VR.VROverlayIntersectionResults_t);
bool flag2 = !overlay.ComputeOverlayIntersection(this.handle, ref vroverlayIntersectionParams_t, ref vroverlayIntersectionResults_t);
if (flag2)
{
result = false;
}
else
{
results.point = new global::UnityEngine.Vector3(vroverlayIntersectionResults_t.vPoint.v0, vroverlayIntersectionResults_t.vPoint.v1, -vroverlayIntersectionResults_t.vPoint.v2);
results.normal = new global::UnityEngine.Vector3(vroverlayIntersectionResults_t.vNormal.v0, vroverlayIntersectionResults_t.vNormal.v1, -vroverlayIntersectionResults_t.vNormal.v2);
results.UVs = new global::UnityEngine.Vector2(vroverlayIntersectionResults_t.vUVs.v0, vroverlayIntersectionResults_t.vUVs.v1);
results.distance = vroverlayIntersectionResults_t.fDistance;
result = true;
}
}
return(result);
}
// Token: 0x06000087 RID: 135 RVA: 0x000064EC File Offset: 0x000046EC
private void Update()
{
bool flag = global::SteamVR_LoadLevel._active != this;
if (!flag)
{
this.alpha = global::UnityEngine.Mathf.Clamp01(this.alpha + this.fadeRate * global::UnityEngine.Time.deltaTime);
global::Valve.VR.CVROverlay overlay = global::Valve.VR.OpenVR.Overlay;
bool flag2 = overlay != null;
if (flag2)
{
bool flag3 = this.loadingScreenOverlayHandle > 0UL;
if (flag3)
{
overlay.SetOverlayAlpha(this.loadingScreenOverlayHandle, this.alpha);
}
bool flag4 = this.progressBarOverlayHandle > 0UL;
if (flag4)
{
overlay.SetOverlayAlpha(this.progressBarOverlayHandle, this.alpha);
}
}
}
}
// Token: 0x0600009D RID: 157 RVA: 0x000073DC File Offset: 0x000055DC
public void UpdateOverlay()
{
global::Valve.VR.CVROverlay overlay = global::Valve.VR.OpenVR.Overlay;
bool flag = overlay == null;
if (!flag)
{
bool flag2 = this.texture != null;
if (flag2)
{
global::Valve.VR.EVROverlayError evroverlayError = overlay.ShowOverlay(this.handle);
bool flag3 = evroverlayError == global::Valve.VR.EVROverlayError.InvalidHandle || evroverlayError == global::Valve.VR.EVROverlayError.UnknownOverlay;
if (flag3)
{
bool flag4 = overlay.FindOverlay(global::SteamVR_Overlay.key, ref this.handle) > global::Valve.VR.EVROverlayError.None;
if (flag4)
{
return;
}
}
global::Valve.VR.Texture_t texture_t = default(global::Valve.VR.Texture_t);
texture_t.handle = this.texture.GetNativeTexturePtr();
texture_t.eType = global::SteamVR.instance.graphicsAPI;
texture_t.eColorSpace = global::Valve.VR.EColorSpace.Auto;
overlay.SetOverlayTexture(this.handle, ref texture_t);
overlay.SetOverlayAlpha(this.handle, this.alpha);
overlay.SetOverlayWidthInMeters(this.handle, this.scale);
overlay.SetOverlayAutoCurveDistanceRangeInMeters(this.handle, this.curvedRange.x, this.curvedRange.y);
global::Valve.VR.VRTextureBounds_t vrtextureBounds_t = default(global::Valve.VR.VRTextureBounds_t);
vrtextureBounds_t.uMin = (0f + this.uvOffset.x) * this.uvOffset.z;
vrtextureBounds_t.vMin = (1f + this.uvOffset.y) * this.uvOffset.w;
vrtextureBounds_t.uMax = (1f + this.uvOffset.x) * this.uvOffset.z;
vrtextureBounds_t.vMax = (0f + this.uvOffset.y) * this.uvOffset.w;
overlay.SetOverlayTextureBounds(this.handle, ref vrtextureBounds_t);
global::Valve.VR.HmdVector2_t hmdVector2_t = default(global::Valve.VR.HmdVector2_t);
hmdVector2_t.v0 = this.mouseScale.x;
hmdVector2_t.v1 = this.mouseScale.y;
overlay.SetOverlayMouseScale(this.handle, ref hmdVector2_t);
global::SteamVR_Camera steamVR_Camera = global::SteamVR_Render.Top();
bool flag5 = steamVR_Camera != null && steamVR_Camera.origin != null;
if (flag5)
{
global::SteamVR_Utils.RigidTransform rigidTransform = new global::SteamVR_Utils.RigidTransform(steamVR_Camera.origin, base.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;
rigidTransform.pos.z = rigidTransform.pos.z + this.distance;
global::Valve.VR.HmdMatrix34_t hmdMatrix34_t = rigidTransform.ToHmdMatrix34();
overlay.SetOverlayTransformAbsolute(this.handle, global::SteamVR_Render.instance.trackingSpace, ref hmdMatrix34_t);
}
overlay.SetOverlayInputMethod(this.handle, this.inputMethod);
bool flag6 = this.curved || this.antialias;
if (flag6)
{
this.highquality = true;
}
bool flag7 = this.highquality;
if (flag7)
{
overlay.SetHighQualityOverlay(this.handle);
overlay.SetOverlayFlag(this.handle, global::Valve.VR.VROverlayFlags.Curved, this.curved);
overlay.SetOverlayFlag(this.handle, global::Valve.VR.VROverlayFlags.RGSS4X, this.antialias);
}
else
{
bool flag8 = overlay.GetHighQualityOverlay() == this.handle;
if (flag8)
{
overlay.SetHighQualityOverlay(0UL);
}
}
}
else
{
overlay.HideOverlay(this.handle);
}
}
}
// Token: 0x06000088 RID: 136 RVA: 0x0000657D File Offset: 0x0000477D
private global::System.Collections.IEnumerator LoadLevel()
{
bool flag = this.loadingScreen != null && this.loadingScreenDistance > 0f;
if (flag)
{
global::SteamVR_Controller.Device hmd = global::SteamVR_Controller.Input(0);
while (!hmd.hasTracking)
{
yield return(null);
}
global::SteamVR_Utils.RigidTransform tloading = hmd.transform;
tloading.rot = global::UnityEngine.Quaternion.Euler(0f, tloading.rot.eulerAngles.y, 0f);
tloading.pos += tloading.rot * new global::UnityEngine.Vector3(0f, 0f, this.loadingScreenDistance);
global::UnityEngine.Transform t = (this.loadingScreenTransform != null) ? this.loadingScreenTransform : base.transform;
t.position = tloading.pos;
t.rotation = tloading.rot;
hmd = null;
tloading = default(global::SteamVR_Utils.RigidTransform);
t = null;
}
global::SteamVR_LoadLevel._active = this;
global::SteamVR_Utils.Event.Send("loading", new object[]
{
true
});
bool flag2 = this.loadingScreenFadeInTime > 0f;
if (flag2)
{
this.fadeRate = 1f / this.loadingScreenFadeInTime;
}
else
{
this.alpha = 1f;
}
global::Valve.VR.CVROverlay overlay = global::Valve.VR.OpenVR.Overlay;
bool flag3 = this.loadingScreen != null && overlay != null;
if (flag3)
{
this.loadingScreenOverlayHandle = this.GetOverlayHandle("loadingScreen", (this.loadingScreenTransform != null) ? this.loadingScreenTransform : base.transform, this.loadingScreenWidthInMeters);
bool flag4 = this.loadingScreenOverlayHandle > 0UL;
if (flag4)
{
global::Valve.VR.Texture_t texture = default(global::Valve.VR.Texture_t);
texture.handle = this.loadingScreen.GetNativeTexturePtr();
texture.eType = global::SteamVR.instance.graphicsAPI;
texture.eColorSpace = global::Valve.VR.EColorSpace.Auto;
overlay.SetOverlayTexture(this.loadingScreenOverlayHandle, ref texture);
}
}
bool fadedForeground = false;
global::SteamVR_Utils.Event.Send("loading_fade_out", new object[]
{
this.fadeOutTime
});
global::Valve.VR.CVRCompositor compositor = global::Valve.VR.OpenVR.Compositor;
bool flag5 = compositor != null;
if (flag5)
{
bool flag6 = this.front != null;
if (flag6)
{
global::SteamVR_Skybox.SetOverride(this.front, this.back, this.left, this.right, this.top, this.bottom);
compositor.FadeGrid(this.fadeOutTime, true);
yield return(new global::UnityEngine.WaitForSeconds(this.fadeOutTime));
}
else
{
bool flag7 = this.backgroundColor != global::UnityEngine.Color.clear;
if (flag7)
{
bool flag8 = this.showGrid;
if (flag8)
{
compositor.FadeToColor(0f, this.backgroundColor.r, this.backgroundColor.g, this.backgroundColor.b, this.backgroundColor.a, true);
compositor.FadeGrid(this.fadeOutTime, true);
yield return(new global::UnityEngine.WaitForSeconds(this.fadeOutTime));
}
else
{
compositor.FadeToColor(this.fadeOutTime, this.backgroundColor.r, this.backgroundColor.g, this.backgroundColor.b, this.backgroundColor.a, false);
yield return(new global::UnityEngine.WaitForSeconds(this.fadeOutTime + 0.1f));
compositor.FadeGrid(0f, true);
fadedForeground = true;
}
}
}
}
global::SteamVR_Render.pauseRendering = true;
while (this.alpha < 1f)
{
yield return(null);
}
base.transform.parent = null;
global::UnityEngine.Object.DontDestroyOnLoad(base.gameObject);
bool flag9 = this.loadExternalApp;
if (flag9)
{
global::UnityEngine.Debug.Log("Launching external application...");
global::Valve.VR.CVRApplications applications = global::Valve.VR.OpenVR.Applications;
bool flag10 = applications == null;
if (flag10)
{
global::UnityEngine.Debug.Log("Failed to get OpenVR.Applications interface!");
}
else
{
string workingDirectory = global::System.IO.Directory.GetCurrentDirectory();
string fullPath = global::System.IO.Path.Combine(workingDirectory, this.externalAppPath);
global::UnityEngine.Debug.Log("LaunchingInternalProcess");
global::UnityEngine.Debug.Log("ExternalAppPath = " + this.externalAppPath);
global::UnityEngine.Debug.Log("FullPath = " + fullPath);
global::UnityEngine.Debug.Log("ExternalAppArgs = " + this.externalAppArgs);
global::UnityEngine.Debug.Log("WorkingDirectory = " + workingDirectory);
global::UnityEngine.Debug.Log("LaunchInternalProcessError: " + applications.LaunchInternalProcess(fullPath, this.externalAppArgs, workingDirectory).ToString());
global::System.Diagnostics.Process.GetCurrentProcess().Kill();
workingDirectory = null;
fullPath = null;
}
applications = null;
}
else
{
global::UnityEngine.SceneManagement.LoadSceneMode mode = this.loadAdditive ? 1 : 0;
bool flag11 = this.loadAsync;
if (flag11)
{
global::UnityEngine.Application.backgroundLoadingPriority = 0;
this.async = global::UnityEngine.SceneManagement.SceneManager.LoadSceneAsync(this.levelName, mode);
while (!this.async.isDone)
{
yield return(null);
}
}
else
{
global::UnityEngine.SceneManagement.SceneManager.LoadScene(this.levelName, mode);
}
}
yield return(null);
global::System.GC.Collect();
yield return(null);
global::UnityEngine.Shader.WarmupAllShaders();
yield return(new global::UnityEngine.WaitForSeconds(this.postLoadSettleTime));
global::SteamVR_Render.pauseRendering = false;
bool flag12 = this.loadingScreenFadeOutTime > 0f;
if (flag12)
{
this.fadeRate = -1f / this.loadingScreenFadeOutTime;
}
else
{
this.alpha = 0f;
}
global::SteamVR_Utils.Event.Send("loading_fade_in", new object[]
{
this.fadeInTime
});
bool flag13 = compositor != null;
if (flag13)
{
bool flag14 = fadedForeground;
if (flag14)
{
compositor.FadeGrid(0f, false);
compositor.FadeToColor(this.fadeInTime, 0f, 0f, 0f, 0f, false);
yield return(new global::UnityEngine.WaitForSeconds(this.fadeInTime));
}
else
{
compositor.FadeGrid(this.fadeInTime, false);
yield return(new global::UnityEngine.WaitForSeconds(this.fadeInTime));
bool flag15 = this.front != null;
if (flag15)
{
global::SteamVR_Skybox.ClearOverride();
}
}
}
while (this.alpha > 0f)
{
yield return(null);
}
bool flag16 = overlay != null;
if (flag16)
{
bool flag17 = this.progressBarOverlayHandle > 0UL;
if (flag17)
{
overlay.HideOverlay(this.progressBarOverlayHandle);
}
bool flag18 = this.loadingScreenOverlayHandle > 0UL;
if (flag18)
{
overlay.HideOverlay(this.loadingScreenOverlayHandle);
}
}
global::UnityEngine.Object.Destroy(base.gameObject);
global::SteamVR_LoadLevel._active = null;
global::SteamVR_Utils.Event.Send("loading", new object[]
{
false
});
yield break;
}
