Ejemplo n.º 1
0
    // 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);
                    }
                }
            }
        }
    }
Ejemplo n.º 2
0
    // 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);
            }
        }
    }
Ejemplo n.º 3
0
    // 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;
    }