// 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: 0x06000695 RID: 1685 RVA: 0x00020414 File Offset: 0x0001E614
public override bool Equals(object o)
{
bool flag = o is global::SteamVR_Utils.RigidTransform;
bool result;
if (flag)
{
global::SteamVR_Utils.RigidTransform rigidTransform = (global::SteamVR_Utils.RigidTransform)o;
result = (this.pos == rigidTransform.pos && this.rot == rigidTransform.rot);
}
else
{
result = false;
}
return(result);
}
// Token: 0x060000D1 RID: 209 RVA: 0x000096E4 File Offset: 0x000078E4
public void UpdateComponents()
{
global::UnityEngine.Transform transform = base.transform;
bool flag = transform.childCount == 0;
if (!flag)
{
using (global::SteamVR_RenderModel.RenderModelInterfaceHolder renderModelInterfaceHolder = new global::SteamVR_RenderModel.RenderModelInterfaceHolder())
{
global::Valve.VR.VRControllerState_t vrcontrollerState_t = (this.index != global::SteamVR_TrackedObject.EIndex.None) ? global::SteamVR_Controller.Input((int)this.index).GetState() : default(global::Valve.VR.VRControllerState_t);
for (int i = 0; i < transform.childCount; i++)
{
global::UnityEngine.Transform child = transform.GetChild(i);
global::Valve.VR.CVRRenderModels instance = renderModelInterfaceHolder.instance;
bool flag2 = instance == null;
if (flag2)
{
break;
}
global::Valve.VR.RenderModel_ComponentState_t renderModel_ComponentState_t = default(global::Valve.VR.RenderModel_ComponentState_t);
bool flag3 = !instance.GetComponentState(this.renderModelName, child.name, ref vrcontrollerState_t, ref this.controllerModeState, ref renderModel_ComponentState_t);
if (!flag3)
{
global::SteamVR_Utils.RigidTransform rigidTransform = new global::SteamVR_Utils.RigidTransform(renderModel_ComponentState_t.mTrackingToComponentRenderModel);
child.localPosition = rigidTransform.pos;
child.localRotation = rigidTransform.rot;
global::UnityEngine.Transform transform2 = child.FindChild("attach");
bool flag4 = transform2 != null;
if (flag4)
{
global::SteamVR_Utils.RigidTransform rigidTransform2 = new global::SteamVR_Utils.RigidTransform(renderModel_ComponentState_t.mTrackingToComponentLocal);
transform2.position = transform.TransformPoint(rigidTransform2.pos);
transform2.rotation = transform.rotation * rigidTransform2.rot;
}
bool flag5 = (renderModel_ComponentState_t.uProperties & 2U) > 0U;
bool flag6 = flag5 != child.gameObject.activeSelf;
if (flag6)
{
child.gameObject.SetActive(flag5);
}
}
}
}
}
}
// Token: 0x060000EB RID: 235 RVA: 0x0000A464 File Offset: 0x00008664
private void OnNewPoses(params object[] args)
{
bool flag = this.index == global::SteamVR_TrackedObject.EIndex.None;
if (!flag)
{
int num = (int)this.index;
this.isValid = false;
global::Valve.VR.TrackedDevicePose_t[] array = (global::Valve.VR.TrackedDevicePose_t[])args[0];
bool flag2 = array.Length <= num;
if (!flag2)
{
bool flag3 = !array[num].bDeviceIsConnected;
if (!flag3)
{
bool flag4 = !array[num].bPoseIsValid;
if (!flag4)
{
this.isValid = true;
global::SteamVR_Utils.RigidTransform rigidTransform = new global::SteamVR_Utils.RigidTransform(array[num].mDeviceToAbsoluteTracking);
bool flag5 = this.origin != null;
if (flag5)
{
rigidTransform = new global::SteamVR_Utils.RigidTransform(this.origin) * rigidTransform;
rigidTransform.pos.x = rigidTransform.pos.x * this.origin.localScale.x;
rigidTransform.pos.y = rigidTransform.pos.y * this.origin.localScale.y;
rigidTransform.pos.z = rigidTransform.pos.z * this.origin.localScale.z;
base.transform.position = rigidTransform.pos;
base.transform.rotation = rigidTransform.rot;
}
else
{
base.transform.localPosition = rigidTransform.pos;
base.transform.localRotation = rigidTransform.rot;
}
}
}
}
}
}
// Token: 0x06000052 RID: 82 RVA: 0x00003ACC File Offset: 0x00001CCC
public static int GetDeviceIndex(global::SteamVR_Controller.DeviceRelation relation, global::Valve.VR.ETrackedDeviceClass deviceClass = global::Valve.VR.ETrackedDeviceClass.Controller, int relativeTo = 0)
{
int num = -1;
global::SteamVR_Utils.RigidTransform t = (relativeTo < 16) ? global::SteamVR_Controller.Input(relativeTo).transform.GetInverse() : global::SteamVR_Utils.RigidTransform.identity;
global::Valve.VR.CVRSystem system = global::Valve.VR.OpenVR.System;
bool flag = system == null;
int result;
if (flag)
{
result = num;
}
else
{
float num2 = float.MinValue;
int num3 = 0;
while ((long)num3 < 16L)
{
bool flag2 = num3 == relativeTo || system.GetTrackedDeviceClass((uint)num3) != deviceClass;
if (!flag2)
{
global::SteamVR_Controller.Device device = global::SteamVR_Controller.Input(num3);
bool flag3 = !device.connected;
if (!flag3)
{
bool flag4 = relation == global::SteamVR_Controller.DeviceRelation.First;
if (flag4)
{
return(num3);
}
global::UnityEngine.Vector3 vector = t * device.transform.pos;
bool flag5 = relation == global::SteamVR_Controller.DeviceRelation.FarthestRight;
float num4;
if (flag5)
{
num4 = vector.x;
}
else
{
bool flag6 = relation == global::SteamVR_Controller.DeviceRelation.FarthestLeft;
if (flag6)
{
num4 = -vector.x;
}
else
{
global::UnityEngine.Vector3 normalized = new global::UnityEngine.Vector3(vector.x, 0f, vector.z).normalized;
float num5 = global::UnityEngine.Vector3.Dot(normalized, global::UnityEngine.Vector3.forward);
global::UnityEngine.Vector3 vector2 = global::UnityEngine.Vector3.Cross(normalized, global::UnityEngine.Vector3.forward);
bool flag7 = relation == global::SteamVR_Controller.DeviceRelation.Leftmost;
if (flag7)
{
num4 = ((vector2.y > 0f) ? (2f - num5) : num5);
}
else
{
num4 = ((vector2.y < 0f) ? (2f - num5) : num5);
}
}
}
bool flag8 = num4 > num2;
if (flag8)
{
num = num3;
num2 = num4;
}
}
}
num3++;
}
result = num;
}
return(result);
}
// Token: 0x06000064 RID: 100 RVA: 0x00004460 File Offset: 0x00002660
public void ReadConfig()
{
try
{
global::Valve.VR.HmdMatrix34_t pose = default(global::Valve.VR.HmdMatrix34_t);
bool flag = false;
object obj = this.config;
string[] array = global::System.IO.File.ReadAllLines(this.configPath);
foreach (string text in array)
{
string[] array3 = text.Split('=', 0);
bool flag2 = array3.Length == 2;
if (flag2)
{
string text2 = array3[0];
bool flag3 = text2 == "m";
if (flag3)
{
string[] array4 = array3[1].Split(',', 0);
bool flag4 = array4.Length == 12;
if (flag4)
{
pose.m0 = float.Parse(array4[0]);
pose.m1 = float.Parse(array4[1]);
pose.m2 = float.Parse(array4[2]);
pose.m3 = float.Parse(array4[3]);
pose.m4 = float.Parse(array4[4]);
pose.m5 = float.Parse(array4[5]);
pose.m6 = float.Parse(array4[6]);
pose.m7 = float.Parse(array4[7]);
pose.m8 = float.Parse(array4[8]);
pose.m9 = float.Parse(array4[9]);
pose.m10 = float.Parse(array4[10]);
pose.m11 = float.Parse(array4[11]);
flag = true;
}
}
else
{
bool flag5 = text2 == "disableStandardAssets";
if (flag5)
{
global::System.Reflection.FieldInfo field = obj.GetType().GetField(text2);
bool flag6 = field != null;
if (flag6)
{
field.SetValue(obj, bool.Parse(array3[1]));
}
}
else
{
global::System.Reflection.FieldInfo field2 = obj.GetType().GetField(text2);
bool flag7 = field2 != null;
if (flag7)
{
field2.SetValue(obj, float.Parse(array3[1]));
}
}
}
}
}
this.config = (global::SteamVR_ExternalCamera.Config)obj;
bool flag8 = flag;
if (flag8)
{
global::SteamVR_Utils.RigidTransform rigidTransform = new global::SteamVR_Utils.RigidTransform(pose);
this.config.x = rigidTransform.pos.x;
this.config.y = rigidTransform.pos.y;
this.config.z = rigidTransform.pos.z;
global::UnityEngine.Vector3 eulerAngles = rigidTransform.rot.eulerAngles;
this.config.rx = eulerAngles.x;
this.config.ry = eulerAngles.y;
this.config.rz = eulerAngles.z;
}
}
catch
{
}
}
// 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: 0x060000E9 RID: 233 RVA: 0x0000A130 File Offset: 0x00008330
private void Update()
{
foreach (int num in this.controllerIndices)
{
global::SteamVR_Overlay instance = global::SteamVR_Overlay.instance;
bool flag = instance && this.point && this.pointer;
if (flag)
{
global::SteamVR_Utils.RigidTransform transform = global::SteamVR_Controller.Input(num).transform;
this.pointer.transform.localPosition = transform.pos;
this.pointer.transform.localRotation = transform.rot;
global::SteamVR_Overlay.IntersectionResults intersectionResults = default(global::SteamVR_Overlay.IntersectionResults);
bool flag2 = instance.ComputeIntersection(transform.pos, transform.rot * global::UnityEngine.Vector3.forward, ref intersectionResults);
bool flag3 = flag2;
if (flag3)
{
this.point.transform.localPosition = intersectionResults.point;
this.point.transform.localRotation = global::UnityEngine.Quaternion.LookRotation(intersectionResults.normal);
}
}
else
{
foreach (global::Valve.VR.EVRButtonId evrbuttonId in this.buttonIds)
{
bool pressDown = global::SteamVR_Controller.Input(num).GetPressDown(evrbuttonId);
if (pressDown)
{
global::UnityEngine.Debug.Log(evrbuttonId.ToString() + " press down");
}
bool pressUp = global::SteamVR_Controller.Input(num).GetPressUp(evrbuttonId);
if (pressUp)
{
global::UnityEngine.Debug.Log(evrbuttonId.ToString() + " press up");
bool flag4 = evrbuttonId == global::Valve.VR.EVRButtonId.k_EButton_Axis1;
if (flag4)
{
global::SteamVR_Controller.Input(num).TriggerHapticPulse(500, global::Valve.VR.EVRButtonId.k_EButton_Axis0);
this.PrintControllerStatus(num);
}
}
bool press = global::SteamVR_Controller.Input(num).GetPress(evrbuttonId);
if (press)
{
global::UnityEngine.Debug.Log(evrbuttonId);
}
}
foreach (global::Valve.VR.EVRButtonId buttonId in this.axisIds)
{
bool touchDown = global::SteamVR_Controller.Input(num).GetTouchDown(buttonId);
if (touchDown)
{
global::UnityEngine.Debug.Log(buttonId.ToString() + " touch down");
}
bool touchUp = global::SteamVR_Controller.Input(num).GetTouchUp(buttonId);
if (touchUp)
{
global::UnityEngine.Debug.Log(buttonId.ToString() + " touch up");
}
bool touch = global::SteamVR_Controller.Input(num).GetTouch(buttonId);
if (touch)
{
global::UnityEngine.Vector2 axis = global::SteamVR_Controller.Input(num).GetAxis(buttonId);
string text = "axis: ";
global::UnityEngine.Vector2 vector = axis;
global::UnityEngine.Debug.Log(text + vector.ToString());
}
}
}
}
}
// Token: 0x060006A1 RID: 1697 RVA: 0x000206BF File Offset: 0x0001E8BF
public void Interpolate(global::SteamVR_Utils.RigidTransform to, float t)
{
this.pos = global::SteamVR_Utils.Lerp(this.pos, to.pos, t);
this.rot = global::SteamVR_Utils.Slerp(this.rot, to.rot, t);
}
// Token: 0x060006A0 RID: 1696 RVA: 0x00020684 File Offset: 0x0001E884
public static global::SteamVR_Utils.RigidTransform Interpolate(global::SteamVR_Utils.RigidTransform a, global::SteamVR_Utils.RigidTransform b, float t)
{
return(new global::SteamVR_Utils.RigidTransform(global::UnityEngine.Vector3.Lerp(a.pos, b.pos, t), global::UnityEngine.Quaternion.Slerp(a.rot, b.rot, t)));
}
// Token: 0x0600069C RID: 1692 RVA: 0x000205CE File Offset: 0x0001E7CE
public void Multiply(global::SteamVR_Utils.RigidTransform a, global::SteamVR_Utils.RigidTransform b)
{
this.rot = a.rot * b.rot;
this.pos = a.pos + a.rot * b.pos;
}
// Token: 0x0600069B RID: 1691 RVA: 0x000205A0 File Offset: 0x0001E7A0
public global::SteamVR_Utils.RigidTransform GetInverse()
{
global::SteamVR_Utils.RigidTransform result = new global::SteamVR_Utils.RigidTransform(this.pos, this.rot);
result.Inverse();
return(result);
}
// 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;
}