SteamVR loading screen not appearing at GameObject Transform?

So, I have an empty GameObject at 0,0,0 and it has the standard SteamVR2.2. plugin "SteamVR_LoadLevel.cs" script component and also my own script to trigger the Steam script.

My custom script is as -

   using System.Collections;
     using UnityEngine;
     using UnityEngine.SceneManagement;
     using UnityEngine.UI;
     using Valve.VR;
     
     
     
     // Use with Button OnClick
     // to load Project scenes using SteamVR_LoadLevel command
     //
     // Craig Simpson April 2019
     
     
     public class SceneLoader : MonoBehaviour
     {
     
         //public Transform currCam;
         private string sceneName;
         private SteamVR_LoadLevel myLoader;
     
         public void LoadScene(int sceneindex)
         {
             //index number "sceneindex" handed down from OnClick button value
     
             //Debug.Log("index number handed down is: " + sceneindex);
             string path = SceneUtility.GetScenePathByBuildIndex(sceneindex);
             //Debug.Log("The requested scene's Project path is: " + path);
             int slash = path.LastIndexOf('/');
             string scenefile = path.Substring(slash + 1);
             //Debug.Log("The scene is: " + scenefile);
             int dot = scenefile.LastIndexOf('.');
             sceneName = scenefile.Substring(0, dot);
             //Debug.Log("The scene string name is: " + scenename);
     
     
             //run scene load
             //GetComponent<SteamVR_LoadLevel>().loadingScreenTransform = currCam;
     
             myLoader = this.GetComponent<SteamVR_LoadLevel>();
     
             myLoader.levelName = sceneName;
             myLoader.Trigger();
     
         }
     
        
     
     }
           
 

and the SteamVR2.2 script is as -

 //======= Copyright (c) Valve Corporation, All rights reserved. ===============
 //
 // Purpose: Helper for smoothing over transitions between levels.
 //
 //=============================================================================
 
 using UnityEngine;
 using System.Collections;
 using Valve.VR;
 using System.IO;
 
 namespace Valve.VR
 {
     public class SteamVR_LoadLevel : MonoBehaviour
     {
 
         
 
         private static SteamVR_LoadLevel _active = null;
         public static bool loading { get { return _active != null; } }
         public static float progress
         {
             get { return (_active != null && _active.async != null) ? _active.async.progress : 0.0f; }
         }
         public static Texture progressTexture
         {
             get { return (_active != null) ? _active.renderTexture : null; }
         }
 
         // Name of level to load.
         public string levelName;
 
         // Name of internal process to launch (instead of levelName).
         public string internalProcessPath;
 
         // The command-line args for the internal process to launch.
         public string internalProcessArgs;
 
         // If true, call LoadLevelAdditiveAsync instead of LoadLevelAsync.
         public bool loadAdditive;
 
         // Async load causes crashes in some apps.
         public bool loadAsync = true;
 
         // Optional logo texture.
         public Texture loadingScreen;
 
         // Optional progress bar textures.
         public Texture progressBarEmpty, progressBarFull;
 
         // Sizes of overlays.
         public float loadingScreenWidthInMeters = 6.0f;
         public float progressBarWidthInMeters = 3.0f;
 
         // If specified, the loading screen will be positioned in the player's view this far away.
         public float loadingScreenDistance = 0.0f;
 
         // Optional overrides for where to display loading screen and progress bar overlays.
         // Otherwise defaults to using this object's transform.
         public Transform loadingScreenTransform, progressBarTransform;
 
         // Optional skybox override textures.
         public Texture front, back, left, right, top, bottom;
 
         // Colors to use when dropping to the compositor between levels if no skybox is set.
         public Color backgroundColor = Color.black;
 
         // If false, the background color above gets applied as the foreground color in the compositor.
         // This does not have any effect when using a skybox instead.
         public bool showGrid = false;
 
         // Time to fade from current scene to the compositor and back.
         public float fadeOutTime = 0.5f;
         public float fadeInTime = 0.5f;
 
         // Additional time to wait after finished loading before we start fading the new scene back in.
         // This is to cover up any initial hitching that takes place right at the start of levels.
         // Most scenes should hopefully not require this.
         public float postLoadSettleTime = 0.0f;
 
         // Time to fade loading screen in and out (also used for progress bar).
         public float loadingScreenFadeInTime = 1.0f;
         public float loadingScreenFadeOutTime = 0.25f;
 
         float fadeRate = 1.0f;
         float alpha = 0.0f;
 
         AsyncOperation async; // used to track level load progress
         RenderTexture renderTexture; // used to render progress bar
 
         ulong loadingScreenOverlayHandle = OpenVR.k_ulOverlayHandleInvalid;
         ulong progressBarOverlayHandle = OpenVR.k_ulOverlayHandleInvalid;
 
         public bool autoTriggerOnEnable = false;
         
         void OnEnable()
         {
             if (autoTriggerOnEnable)
                 Trigger();
         }
 
         public void Trigger()
         {
             if (!loading && !string.IsNullOrEmpty(levelName))
                 StartCoroutine(LoadLevel());
         }
 
         // Helper function to quickly and simply load a level from script.
         public static void Begin(string levelName,
             bool showGrid = false, float fadeOutTime = 0.5f,
             float r = 0.0f, float g = 0.0f, float b = 0.0f, float a = 1.0f)
         {
             var loader = new GameObject("loader").AddComponent<SteamVR_LoadLevel>();
             loader.levelName = levelName;
             loader.showGrid = showGrid;
             loader.fadeOutTime = fadeOutTime;
             loader.backgroundColor = new Color(r, g, b, a);
             loader.Trigger();
         }
 
         // Updates progress bar.
         void OnGUI()
         {
             if (_active != this)
                 return;
 
             // Optionally create an overlay for our progress bar to use, separate from the loading screen.
             if (progressBarEmpty != null && progressBarFull != null)
             {
                 if (progressBarOverlayHandle == OpenVR.k_ulOverlayHandleInvalid)
                     progressBarOverlayHandle = GetOverlayHandle("progressBar", progressBarTransform != null ? progressBarTransform : transform, progressBarWidthInMeters);
 
                 if (progressBarOverlayHandle != OpenVR.k_ulOverlayHandleInvalid)
                 {
                     var progress = (async != null) ? async.progress : 0.0f;
 
                     // Use the full bar size for everything.
                     var w = progressBarFull.width;
                     var h = progressBarFull.height;
 
                     // Create a separate render texture so we can composite the full image on top of the empty one.
                     if (renderTexture == null)
                     {
                         renderTexture = new RenderTexture(w, h, 0);
                         renderTexture.Create();
                     }
 
                     var prevActive = RenderTexture.active;
                     RenderTexture.active = renderTexture;
 
                     if (Event.current.type == EventType.Repaint)
                         GL.Clear(false, true, Color.clear);
 
                     GUILayout.BeginArea(new Rect(0, 0, w, h));
 
                     GUI.DrawTexture(new Rect(0, 0, w, h), progressBarEmpty);
 
                     // Reveal the full bar texture based on progress.
                     GUI.DrawTextureWithTexCoords(new Rect(0, 0, progress * w, h), progressBarFull, new Rect(0.0f, 0.0f, progress, 1.0f));
 
                     GUILayout.EndArea();
 
                     RenderTexture.active = prevActive;
 
                     // Texture needs to be set every frame after it is updated since SteamVR makes a copy internally to a shared texture.
                     var overlay = OpenVR.Overlay;
                     if (overlay != null)
                     {
                         var texture = new Texture_t();
                         texture.handle = renderTexture.GetNativeTexturePtr();
                         texture.eType = SteamVR.instance.textureType;
                         texture.eColorSpace = EColorSpace.Auto;
                         overlay.SetOverlayTexture(progressBarOverlayHandle, ref texture);
                     }
                 }
             }
 
 #if false
         // Draw loading screen and progress bar to 2d companion window as well.
         if (loadingScreen != null)
         {
             var screenAspect = (float)Screen.width / Screen.height;
             var textureAspect = (float)loadingScreen.width / loadingScreen.height;
 
             float w, h;
             if (screenAspect < textureAspect)
             {
                 // Clamp horizontally
                 w = Screen.width * 0.9f;
                 h = w / textureAspect;
             }
             else
             {
                 // Clamp vertically
                 h = Screen.height * 0.9f;
                 w = h * textureAspect;
             }
 
             GUILayout.BeginArea(new Rect(0, 0, Screen.width, Screen.height));
 
             var x = Screen.width / 2 - w / 2;
             var y = Screen.height / 2 - h / 2;
             GUI.DrawTexture(new Rect(x, y, w, h), loadingScreen);
 
             GUILayout.EndArea();
         }
 
         if (renderTexture != null)
         {
             var x = Screen.width / 2 - renderTexture.width / 2;
             var y = Screen.height * 0.9f - renderTexture.height;
             GUI.DrawTexture(new Rect(x, y, renderTexture.width, renderTexture.height), renderTexture);
         }
 #endif
         }
 
         // Fade our overlays in/out over time.
         void Update()
         {
 
             if (_active != this)
                 return;
 
             alpha = Mathf.Clamp01(alpha + fadeRate * Time.deltaTime);
 
             var overlay = OpenVR.Overlay;
             if (overlay != null)
             {
                 if (loadingScreenOverlayHandle != OpenVR.k_ulOverlayHandleInvalid)
                     overlay.SetOverlayAlpha(loadingScreenOverlayHandle, alpha);
 
                 if (progressBarOverlayHandle != OpenVR.k_ulOverlayHandleInvalid)
                     overlay.SetOverlayAlpha(progressBarOverlayHandle, alpha);
             }
         }
 
         // Corourtine to handle all the steps across loading boundaries.
         IEnumerator LoadLevel()
         {
             // Optionally rotate loading screen transform around the camera into view.
             // We assume here that the loading screen is already facing toward the origin,
             // and that the progress bar transform (if any) is a child and will follow along.
             if (loadingScreen != null && loadingScreenDistance > 0.0f)
             {
                 // Transform of the Gameobject, unless.....
                 Transform hmd = this.transform;
                 // A camera is attached
                 if (Camera.main != null)
                     hmd = Camera.main.transform;
 
                 Quaternion rot = Quaternion.Euler(0.0f, hmd.eulerAngles.y, 0.0f);
                 Vector3 pos = hmd.position + (rot * new Vector3(0.0f, 0.0f, loadingScreenDistance));
                 //Debug.Log("This HUD transform is " + hmd.position);
                 //Debug.Log("This HUD rotation Euler is " + rot);
                 //Debug.Log("This HUD rotation Y angle is " + hmd.eulerAngles.y);
                 //Debug.Log("This HUD plus screen distance is the GameObject Transform now, it is " + pos);
                 var t = loadingScreenTransform != null ? loadingScreenTransform : transform;
                 t.position = pos;
                 t.rotation = rot;
             }
 
             _active = this;
 
             SteamVR_Events.Loading.Send(true);
 
             // Calculate rate for fading in loading screen and progress bar.
             if (loadingScreenFadeInTime > 0.0f)
             {
                 fadeRate = 1.0f / loadingScreenFadeInTime;
             }
             else
             {
                 alpha = 1.0f;
             }
 
             var overlay = OpenVR.Overlay;
 
             // Optionally create our loading screen overlay.
             if (loadingScreen != null && overlay != null)
             {
                 //Debug.Log("Loading screen and overlay are NOT null");
                 loadingScreenOverlayHandle = GetOverlayHandle("loadingScreen", loadingScreenTransform != null ? loadingScreenTransform : transform, loadingScreenWidthInMeters);
                 
                 if (loadingScreenOverlayHandle != OpenVR.k_ulOverlayHandleInvalid)
                 {
                     var texture = new Texture_t();
                     texture.handle = loadingScreen.GetNativeTexturePtr();
                     texture.eType = SteamVR.instance.textureType;
                     texture.eColorSpace = EColorSpace.Auto;
                     overlay.SetOverlayTexture(loadingScreenOverlayHandle, ref texture);
                 }
             }
 
             bool fadedForeground = false;
 
             // Fade out to compositor
             SteamVR_Events.LoadingFadeOut.Send(fadeOutTime);
 
             // Optionally set a skybox to use as a backdrop in the compositor.
             var compositor = OpenVR.Compositor;
             if (compositor != null)
             {
                 if (front != null)
                 {
                     SteamVR_Skybox.SetOverride(front, back, left, right, top, bottom);
 
                     // Explicitly fade to the compositor since loading will cause us to stop rendering.
                     compositor.FadeGrid(fadeOutTime, true);
                     yield return new WaitForSeconds(fadeOutTime);
                 }
                 else if (backgroundColor != Color.clear)
                 {
                     // Otherwise, use the specified background color.
                     if (showGrid)
                     {
                         // Set compositor background color immediately, and start fading to it.
                         compositor.FadeToColor(0.0f, backgroundColor.r, backgroundColor.g, backgroundColor.b, backgroundColor.a, true);
                         compositor.FadeGrid(fadeOutTime, true);
                         yield return new WaitForSeconds(fadeOutTime);
                     }
                     else
                     {
                         // Fade the foreground color in (which will blend on top of the scene), and then cut to the compositor.
                         compositor.FadeToColor(fadeOutTime, backgroundColor.r, backgroundColor.g, backgroundColor.b, backgroundColor.a, false);
                         yield return new WaitForSeconds(fadeOutTime + 0.1f);
                         compositor.FadeGrid(0.0f, true);
                         fadedForeground = true;
                     }
                 }
             }
 
             // Now that we're fully faded out, we can stop submitting frames to the compositor.
             SteamVR_Render.pauseRendering = true;
 
             // Continue waiting for the overlays to fully fade in before continuing.
             while (alpha < 1.0f)
                 yield return null;
 
             // Keep us from getting destroyed when loading the new level, otherwise this coroutine will get stopped prematurely.
             transform.parent = null;
             DontDestroyOnLoad(gameObject);
 
             if (!string.IsNullOrEmpty(internalProcessPath))
             {
                 Debug.Log("<b>[SteamVR]</b> Launching external application...");
                 var applications = OpenVR.Applications;
                 if (applications == null)
                 {
                     Debug.Log("<b>[SteamVR]</b> Failed to get OpenVR.Applications interface!");
                 }
                 else
                 {
                     var workingDirectory = Directory.GetCurrentDirectory();
                     var fullPath = Path.Combine(workingDirectory, internalProcessPath);
                     Debug.Log("<b>[SteamVR]</b> LaunchingInternalProcess");
                     Debug.Log("<b>[SteamVR]</b> ExternalAppPath = " + internalProcessPath);
                     Debug.Log("<b>[SteamVR]</b> FullPath = " + fullPath);
                     Debug.Log("<b>[SteamVR]</b> ExternalAppArgs = " + internalProcessArgs);
                     Debug.Log("<b>[SteamVR]</b> WorkingDirectory = " + workingDirectory);
                     var error = applications.LaunchInternalProcess(fullPath, internalProcessArgs, workingDirectory);
                     Debug.Log("<b>[SteamVR]</b> LaunchInternalProcessError: " + error);
 #if UNITY_EDITOR
                     UnityEditor.EditorApplication.isPlaying = false;
 #elif !UNITY_METRO
                 System.Diagnostics.Process.GetCurrentProcess().Kill();
 #endif
                 }
             }
             else
             {
                 var mode = loadAdditive ? UnityEngine.SceneManagement.LoadSceneMode.Additive : UnityEngine.SceneManagement.LoadSceneMode.Single;
                 if (loadAsync)
                 {
                     Application.backgroundLoadingPriority = ThreadPriority.Low;
                     async = UnityEngine.SceneManagement.SceneManager.LoadSceneAsync(levelName, mode);
 
                     // Performing this in a while loop instead seems to help smooth things out.
                     //yield return async;
                     while (!async.isDone)
                     {
                         yield return null;
                     }
                 }
                 else
                 {
                     UnityEngine.SceneManagement.SceneManager.LoadScene(levelName, mode);
                 }
             }
 
             yield return null;
 
             System.GC.Collect();
 
             yield return null;
 
             Shader.WarmupAllShaders();
 
             // Optionally wait a short period of time after loading everything back in, but before we start rendering again
             // in order to give everything a change to settle down to avoid any hitching at the start of the new level.
             yield return new WaitForSeconds(postLoadSettleTime);
 
             SteamVR_Render.pauseRendering = false;
 
             // Fade out loading screen.
             if (loadingScreenFadeOutTime > 0.0f)
             {
                 fadeRate = -1.0f / loadingScreenFadeOutTime;
             }
             else
             {
                 alpha = 0.0f;
             }
 
             // Fade out to compositor
             SteamVR_Events.LoadingFadeIn.Send(fadeInTime);
 
             // Refresh compositor reference since loading scenes might have invalidated it.
             compositor = OpenVR.Compositor;
             if (compositor != null)
             {
                 // Fade out foreground color if necessary.
                 if (fadedForeground)
                 {
                     compositor.FadeGrid(0.0f, false);
                     compositor.FadeToColor(fadeInTime, 0.0f, 0.0f, 0.0f, 0.0f, false);
                     yield return new WaitForSeconds(fadeInTime);
                 }
                 else
                 {
                     // Fade scene back in, and reset skybox once no longer visible.
                     compositor.FadeGrid(fadeInTime, false);
                     yield return new WaitForSeconds(fadeInTime);
 
                     if (front != null)
                     {
                         SteamVR_Skybox.ClearOverride();
                     }
                 }
             }
 
             // Finally, stick around long enough for our overlays to fully fade out.
             while (alpha > 0.0f)
                 yield return null;
 
             if (overlay != null)
             {
                 if (progressBarOverlayHandle != OpenVR.k_ulOverlayHandleInvalid)
                     overlay.HideOverlay(progressBarOverlayHandle);
                 if (loadingScreenOverlayHandle != OpenVR.k_ulOverlayHandleInvalid)
                     overlay.HideOverlay(loadingScreenOverlayHandle);
             }
 
             Destroy(gameObject);
 
             _active = null;
 
             SteamVR_Events.Loading.Send(false);
         }
 
         // Helper to create (or reuse if possible) each of our different overlay types.
         ulong GetOverlayHandle(string overlayName, Transform transform, float widthInMeters = 1.0f)
         {
             ulong handle = OpenVR.k_ulOverlayHandleInvalid;
             
 
             var overlay = OpenVR.Overlay;
             if (overlay == null)
                 return handle;
                 
 
             var key = SteamVR_Overlay.key + "." + overlayName;
 
             var error = overlay.FindOverlay(key, ref handle);
             if (error != EVROverlayError.None)
                 error = overlay.CreateOverlay(key, overlayName, ref handle);
             if (error == EVROverlayError.None)
             {
                 overlay.ShowOverlay(handle);
                 overlay.SetOverlayAlpha(handle, alpha);
                 overlay.SetOverlayWidthInMeters(handle, widthInMeters);
 
                 // D3D textures are upside-down in Unity to match OpenGL.
                 if (SteamVR.instance.textureType == ETextureType.DirectX)
                 {
                     var textureBounds = new VRTextureBounds_t();
                     textureBounds.uMin = 0;
                     textureBounds.vMin = 1;
                     textureBounds.uMax = 1;
                     textureBounds.vMax = 0;
                     overlay.SetOverlayTextureBounds(handle, ref textureBounds);
                 }
 
                 // Convert from world space to tracking space using the top-most camera.
                 var vrcam = (loadingScreenDistance == 0.0f) ? SteamVR_Render.Top() : null;
                 if (vrcam != null && vrcam.origin != null)
                 {
                     //Debug.Log("First part world space");
                     var offset = new SteamVR_Utils.RigidTransform(vrcam.origin, transform);
                     offset.pos.x /= vrcam.origin.localScale.x;
                     offset.pos.y /= vrcam.origin.localScale.y;
                     offset.pos.z /= vrcam.origin.localScale.z;
                     var t = offset.ToHmdMatrix34();
                     overlay.SetOverlayTransformAbsolute(handle, SteamVR.settings.trackingSpace, ref t);
                 }
                 else
                 {
                     //Debug.Log("Second part world space");
                     var t = new SteamVR_Utils.RigidTransform(transform).ToHmdMatrix34();
                     overlay.SetOverlayTransformAbsolute(handle, SteamVR.settings.trackingSpace, ref t);
                 }
             }
 
             return handle;
         }
     }
 }

I hope this helps. As the GameObject transform is exactly where It should be I can not understand why the actual loading screen appears in another location??

Hi, can you maybe post the script that you are referring to? You might've missed something and need someone else to take a look at it. Describing your problem with no reference doesn't allow for us to easily help you

Hi, @CraigSimpson have you got into the working state? I am also facing the same issue now.