diff --git a/KerbalVR/Assets/app_button_logo.png b/KerbalVR/Assets/app_button_logo.png
new file mode 100644
index 00000000..63441c7e
Binary files /dev/null and b/KerbalVR/Assets/app_button_logo.png differ
diff --git a/KerbalVR/KerbalVR.csproj b/KerbalVR/KerbalVR.csproj
index 2dc7fce5..5134e0d8 100644
--- a/KerbalVR/KerbalVR.csproj
+++ b/KerbalVR/KerbalVR.csproj
@@ -93,6 +93,7 @@
     </Reference>
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="KerbalVR_GUI.cs" />
     <Compile Include="KerbalVR_MathUtils.cs" />
     <Compile Include="KerbalVR_Plugin.cs" />
     <Compile Include="KerbalVR_Utils.cs" />
@@ -128,40 +129,25 @@
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <PropertyGroup>
-    <PostBuildEvent>mkdir "$(TargetDir)rel\GameData\KerbalVR\openvr"
-
-
+    <PostBuildEvent>:: Create a release folder
+mkdir "$(TargetDir)rel\GameData\KerbalVR\openvr"
+mkdir "$(TargetDir)rel\GameData\KerbalVR\Assets"
 copy /Y "$(TargetDir)"\"$(TargetFileName)" "$(TargetDir)\rel\GameData\KerbalVR\"
 copy /Y "$(SolutionDir)"\LICENSE "$(TargetDir)\rel\"
-
-
 copy /Y "$(SolutionDir)\README.md" "$(TargetDir)\rel\"
-
-
 robocopy "$(ProjectDir)lib" "$(TargetDir)\rel\GameData\KerbalVR\openvr" /E
+robocopy "$(ProjectDir)Assets" "$(TargetDir)\rel\GameData\KerbalVR\Assets" /E
 
-
-
-
-
+:: Copy release into KSP directory
 if $(PlatformName) == x64 (
-
-
   robocopy "$(TargetDir)\rel\GameData\KerbalVR" "C:\KSP_win64\GameData\KerbalVR" /E
-
-
-)
-
- else (
-
+) else (
   robocopy "$(TargetDir)\rel\GameData\KerbalVR" "C:\KSP_win\GameData\KerbalVR" /E
-
-
 )
 
-
-
-copy /Y "$(ProjectDir)\LICENSE-openvr" "$(TargetDir)\rel\GameData\KerbalVR\openvr"</PostBuildEvent>
+:: robocopy gives a bad return value. Leave this copy as the last step.
+copy /Y "$(ProjectDir)\LICENSE-openvr" "$(TargetDir)\rel\GameData\KerbalVR\openvr"
+</PostBuildEvent>
   </PropertyGroup>
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
diff --git a/KerbalVR/KerbalVR_GUI.cs b/KerbalVR/KerbalVR_GUI.cs
new file mode 100644
index 00000000..f793641e
--- /dev/null
+++ b/KerbalVR/KerbalVR_GUI.cs
@@ -0,0 +1,170 @@
+using UnityEngine;
+using KSP.UI.Screens;
+using System.Text.RegularExpressions;
+
+namespace KerbalVR
+{
+    public class KerbalVR_GUI
+    {
+        // CONSTANTS
+        //
+        public static string AppButtonLogo {
+            get {
+                return Utils.KERBALVR_ASSETS_DIR + "app_button_logo";
+            }
+        }
+
+        private static string BUTTON_STRING_ENABLE_VR = "Enable VR";
+        private static string BUTTON_STRING_DISABLE_VR = "Disable VR";
+
+        private static string LABEL_STRING_VR_ACTIVE = "ACTIVE";
+        private static string LABEL_STRING_VR_INACTIVE = "INACTIVE";
+
+        private static readonly int APP_GUI_ID = 186012;
+
+        // store the interface to the KerbalVR plugin
+        private KerbalVR_Plugin kerbalVr;
+
+        private ApplicationLauncherButton appButton;
+        private bool appButtonGuiActive = false;
+
+        private Rect appGuiWindowRect = new Rect(Screen.width / 4, Screen.height / 4, 160, 100);
+
+
+        public KerbalVR_GUI(KerbalVR_Plugin kerbalVr) {
+            this.kerbalVr = kerbalVr;
+        }
+
+        /// <summary>
+        /// This GameEvent is registered with GameEvents.onGUIApplicationLauncherReady,
+        /// at the time the plugin is loaded. It instantiates a new button on the
+        /// application launcher.
+        /// </summary>
+        public void OnAppLauncherReady() {
+            // define where should the app button be visible
+            ApplicationLauncher.AppScenes appVisibility =
+                ApplicationLauncher.AppScenes.SPACECENTER |
+                ApplicationLauncher.AppScenes.FLIGHT |
+                ApplicationLauncher.AppScenes.MAPVIEW |
+                ApplicationLauncher.AppScenes.VAB |
+                ApplicationLauncher.AppScenes.SPH |
+                ApplicationLauncher.AppScenes.TRACKSTATION;
+            
+            // create new app button instance
+            if (HighLogic.LoadedScene == GameScenes.SPACECENTER &&
+                appButton == null) {
+                appButton = ApplicationLauncher.Instance.AddModApplication(
+                    OnToggleTrue,
+                    OnToggleFalse,
+                    null, null, null, null,
+                    appVisibility,
+                    GameDatabase.Instance.GetTexture(AppButtonLogo, false));
+            }
+
+            // GUI is off at instantiation
+            appButtonGuiActive = false;
+        }
+
+        /// <summary>
+        /// This GameEvent is registered with GameEvents.onGUIApplicationLauncherDestroyed,
+        /// at the time the plugin is loaded. It destroys the application button on the
+        /// application launcher.
+        /// </summary>
+        public void OnAppLauncherDestroyed() {
+            if (appButton != null) {
+                ApplicationLauncher.Instance.RemoveApplication(appButton);
+            }
+        }
+
+        /// <summary>
+        /// Callback when the application button is toggled on.
+        /// </summary>
+        public void OnToggleTrue() {
+            appButtonGuiActive = true;
+        }
+
+        /// <summary>
+        /// Callback when the application button is toggled off.
+        /// </summary>
+        public void OnToggleFalse() {
+            appButtonGuiActive = false;
+        }
+
+        public void OnGUI() {
+            if (appButtonGuiActive) {
+                appGuiWindowRect = GUILayout.Window(
+                    APP_GUI_ID,
+                    appGuiWindowRect,
+                    GenerateGUI,
+                    "KerbalVR",
+                    HighLogic.Skin.window);
+            }
+        }
+
+        //int poseDelayMS = 0;
+
+        private void GenerateGUI(int windowId) {
+            string buttonStringToggleVr = BUTTON_STRING_ENABLE_VR;
+            string labelStringVrActive = LABEL_STRING_VR_INACTIVE;
+            GUIStyle labelStyleVrActive = new GUIStyle(HighLogic.Skin.label);
+            labelStyleVrActive.normal.textColor = Color.red;
+
+            if (kerbalVr.HmdIsEnabled) {
+                buttonStringToggleVr = BUTTON_STRING_DISABLE_VR;
+                labelStringVrActive = LABEL_STRING_VR_ACTIVE;
+                labelStyleVrActive.normal.textColor = Color.green;
+            }
+
+            GUILayout.BeginVertical();
+
+            // VR toggle button
+            GUI.enabled = kerbalVr.HmdIsAllowed;
+            if (GUILayout.Button(buttonStringToggleVr, HighLogic.Skin.button)) {
+                if (kerbalVr.HmdIsEnabled) {
+                    kerbalVr.HmdIsEnabled = false;
+                } else {
+                    kerbalVr.HmdIsEnabled = true;
+                }
+            }
+
+            if (GUILayout.Button("Reset Headset Position", HighLogic.Skin.button)) {
+                kerbalVr.ResetInitialHmdPosition();
+            }
+            GUI.enabled = true;
+
+            // VR status
+            GUILayout.BeginHorizontal();
+            GUILayout.Label("VR Status:", HighLogic.Skin.label);
+            GUILayout.Label(labelStringVrActive, labelStyleVrActive);
+            GUILayout.EndHorizontal();
+
+#if DEBUG
+
+            // settings
+            GUIStyle labelStyleHeader = new GUIStyle(HighLogic.Skin.label);
+            labelStyleHeader.fontStyle = FontStyle.Bold;
+            GUILayout.Label("Options", labelStyleHeader);
+
+            GUILayout.BeginHorizontal();
+            GUILayout.Label("Pose Delay (ms):", HighLogic.Skin.label);
+            int poseDelayMS = (int)(kerbalVr.PoseDelay * 1000f);
+            string poseDelayStr = poseDelayMS.ToString();
+            poseDelayStr = GUILayout.TextField(poseDelayStr, HighLogic.Skin.textField);
+            if (GUI.changed) {
+                if (System.Int32.TryParse(poseDelayStr, out poseDelayMS)) {
+                    kerbalVr.PoseDelay = poseDelayMS * 0.001f;
+                } else {
+                    kerbalVr.PoseDelay = 0f;
+                }
+            }
+            GUILayout.EndHorizontal();
+
+#endif
+
+            GUILayout.EndVertical();
+
+            // allow dragging the window
+            GUI.DragWindow();
+        }
+    }
+}
diff --git a/KerbalVR/KerbalVR_Plugin.cs b/KerbalVR/KerbalVR_Plugin.cs
index 543cf3d5..02532077 100644
--- a/KerbalVR/KerbalVR_Plugin.cs
+++ b/KerbalVR/KerbalVR_Plugin.cs
@@ -8,29 +8,66 @@ namespace KerbalVR
 {
     // Start plugin on entering the Flight scene
     //
-    [KSPAddon(KSPAddon.Startup.Flight, false)]
+    [KSPAddon(KSPAddon.Startup.Instantly, false)]
     public class KerbalVR_Plugin : MonoBehaviour
     {
+
+        private uint controlIndexL = 0;
+        private uint controlIndexR = 0;
+
         // this function allows importing DLLs from a given path
         [DllImport("kernel32.dll", SetLastError = true)]
         static extern bool SetDllDirectory(string lpPathName);
 
         private bool hmdIsInitialized = false;
-        private bool hmdIsAllowed = false;
-        private bool hmdIsEnabled = false;
         private bool hmdIsRunning = false;
         private bool hmdIsRunningPrev = false;
 
+        // enable and disable VR functionality
+        private bool _hmdIsEnabled;
+        public bool HmdIsEnabled {
+            get { return _hmdIsEnabled; }
+            set {
+                _hmdIsEnabled = value;
+
+                Utils.LogInfo("HMD " + (value ? "enabled" : "disabled"));
+
+                if (_hmdIsEnabled) {
+                    InitVRScene();
+                    ResetInitialHmdPosition();
+                }
+            }
+        }
+
+        // check if VR can be enabled
+        public bool HmdIsAllowed { get; private set; }
+
         private CVRSystem vrSystem;
         private CVRCompositor vrCompositor;
         private TrackedDevicePose_t[] vrDevicePoses = new TrackedDevicePose_t[OpenVR.k_unMaxTrackedDeviceCount];
         private TrackedDevicePose_t[] vrRenderPoses = new TrackedDevicePose_t[OpenVR.k_unMaxTrackedDeviceCount];
         private TrackedDevicePose_t[] vrGamePoses = new TrackedDevicePose_t[OpenVR.k_unMaxTrackedDeviceCount];
+
+        private float _poseDelay;
+        public float PoseDelay {
+            get {
+                return _poseDelay;
+            }
+            set {
+                _poseDelay = value;
+                Utils.LogInfo("Set Pose Delay to: " + _poseDelay.ToString("F3"));
+            }
+        }
         
         private Texture_t hmdLeftEyeTexture, hmdRightEyeTexture;
         private VRTextureBounds_t hmdTextureBounds;
         private RenderTexture hmdLeftEyeRenderTexture, hmdRightEyeRenderTexture;
-        
+
+        private KerbalVR_GUI gui;
+
+        private Vector3 ivaInitialPosition;
+        private Quaternion ivaInitialRotation;
+
 
         // list of all cameras in the game
         //--------------------------------------------------------------
@@ -66,49 +103,52 @@ public CameraProperties(Camera camera, Matrix4x4 originalProjMatrix, Matrix4x4 h
         }
 
         // list of cameras to render (Camera objects)
-        private List<CameraProperties> camerasToRender;
+        private CameraProperties[] camerasToRender;
+        private int numCamerasToRender;
+
+        public void Awake() {
+            Utils.LogInfo("KerbalVrPlugin started.");
+
+            // init objects
+            gui = new KerbalVR_GUI(this);
+            _hmdIsEnabled = false;
+            HmdIsAllowed = false;
+            PoseDelay = 0f;
+        }
 
         /// <summary>
         /// Overrides the Start method for a MonoBehaviour plugin.
         /// </summary>
         public void Start() {
-            Utils.LogInfo("KerbalVrPlugin started.");
-
             // add an event triggered when game scene changes, to handle
             // shutting off the HMD outside of Flight scene
             GameEvents.onGameSceneLoadRequested.Add(OnGameSceneLoadRequested);
 
             // initialize the OpenVR API
-            InitHMD();
+            bool success = InitHMD();
+            if (!success) {
+                Utils.LogError("Unable to initialize VR headset!");
+            }
 
             // don't destroy this object when switching scenes
-            // TODO: investigate if we really want this behavior
             DontDestroyOnLoad(this);
+
+            // when ready for a GUI, load it
+            GameEvents.onGUIApplicationLauncherReady.Add(gui.OnAppLauncherReady);
+            GameEvents.onGUIApplicationLauncherDestroyed.Add(gui.OnAppLauncherDestroyed);
         }
 
         /// <summary>
-        /// Overrides the Update method, called every frame.
+        /// Overrides the LateUpdate method, called every frame.
         /// </summary>
         public void LateUpdate() {
-
-            // start HMD using the Y key
-            if (Input.GetKeyDown(KeyCode.Y)) {
-                hmdIsEnabled = !hmdIsEnabled;
-                Utils.LogInfo("HMD enabled: " + hmdIsEnabled);
-
-                if (hmdIsEnabled) {
-                    InitVRScene();
-                    ResetInitialHmdPosition();
-                }
-            }
-
             // do nothing unless we are in IVA
-            hmdIsAllowed = HighLogic.LoadedSceneIsFlight &&
+            HmdIsAllowed = HighLogic.LoadedSceneIsFlight &&
                 (CameraManager.Instance != null) &&
                 (CameraManager.Instance.currentCameraMode == CameraManager.CameraMode.IVA);
 
-            // check we are running the HMD
-            hmdIsRunning = hmdIsAllowed && hmdIsInitialized && hmdIsEnabled;
+            // check if we are running the HMD
+            hmdIsRunning = HmdIsAllowed && hmdIsInitialized && HmdIsEnabled;
 
             // perform regular updates if HMD is initialized
             if (hmdIsRunning) {
@@ -118,9 +158,19 @@ public void LateUpdate() {
 
                     // TODO: investigate if we should really be capturing poses in LateUpdate
 
+                    // detect controllers
+                    //--------------------------------------------------------------
+                    for (uint idx = 0; idx < OpenVR.k_unMaxTrackedDeviceCount; idx++) {
+                        if ((controlIndexL == 0) && (vrSystem.GetTrackedDeviceClass(idx) == ETrackedDeviceClass.Controller)) {
+                            controlIndexL = idx;
+                        } else if ((controlIndexR == 0) && (vrSystem.GetTrackedDeviceClass(idx) == ETrackedDeviceClass.Controller)) {
+                            controlIndexR = idx;
+                        }
+                    }
+
                     // get latest HMD pose
                     //--------------------------------------------------------------
-                    vrSystem.GetDeviceToAbsoluteTrackingPose(ETrackingUniverseOrigin.TrackingUniverseSeated, 0.0f, vrDevicePoses);
+                    vrSystem.GetDeviceToAbsoluteTrackingPose(ETrackingUniverseOrigin.TrackingUniverseSeated, PoseDelay, vrDevicePoses);
                     HmdMatrix34_t vrLeftEyeTransform = vrSystem.GetEyeToHeadTransform(EVREye.Eye_Left);
                     HmdMatrix34_t vrRightEyeTransform = vrSystem.GetEyeToHeadTransform(EVREye.Eye_Right);
                     vrCompositorError = vrCompositor.WaitGetPoses(vrRenderPoses, vrGamePoses);
@@ -134,7 +184,12 @@ public void LateUpdate() {
                     var hmdLeftEyeTransform = new SteamVR_Utils.RigidTransform(vrLeftEyeTransform);
                     var hmdRightEyeTransform = new SteamVR_Utils.RigidTransform(vrRightEyeTransform);
 
+                    if (controlIndexL > 0) {
+                        SteamVR_Utils.RigidTransform ctrlPoseLeft = new SteamVR_Utils.RigidTransform(vrDevicePoses[controlIndexL].mDeviceToAbsoluteTracking);
+                    }
+
                     // Render the LEFT eye
+                    //--------------------------------------------------------------
                     RenderHmdCameras(
                         EVREye.Eye_Left,
                         hmdTransform,
@@ -143,6 +198,7 @@ public void LateUpdate() {
                         hmdLeftEyeTexture);
 
                     // Render the RIGHT eye
+                    //--------------------------------------------------------------
                     RenderHmdCameras(
                         EVREye.Eye_Right,
                         hmdTransform,
@@ -154,7 +210,7 @@ public void LateUpdate() {
 
                 } catch (Exception e) {
                     Utils.LogError(e);
-                    hmdIsEnabled = false;
+                    HmdIsEnabled = false;
                     hmdIsRunning = false;
                 }
 
@@ -173,12 +229,75 @@ public void LateUpdate() {
                 foreach (CameraProperties camStruct in camerasToRender) {
                     camStruct.camera.targetTexture = null;
                     camStruct.camera.projectionMatrix = camStruct.originalProjMatrix;
+                    camStruct.camera.enabled = true;
                 }
             }
+            
 
             hmdIsRunningPrev = hmdIsRunning;
         }
-        
+
+        private void RenderHmdCameras(
+            EVREye eye,
+            SteamVR_Utils.RigidTransform hmdTransform,
+            SteamVR_Utils.RigidTransform hmdEyeTransform,
+            RenderTexture hmdEyeRenderTexture,
+            Texture_t hmdEyeTexture) {
+
+            /**
+             * hmdEyeTransform is in a coordinate system that follows the headset, where
+             * the origin is the headset device position. Therefore the eyes are at a constant
+             * offset from the device. hmdEyeTransform does not change (per eye).
+             *      hmdEyeTransform.x+  towards the right of the headset
+             *      hmdEyeTransform.y+  towards the top the headset
+             *      hmdEyeTransform.z+  towards the front of the headset
+             *
+             * hmdTransform is in a coordinate system set in physical space, where the
+             * origin is the initial seated position.
+             *      hmdTransform.x+     towards the right
+             *      hmdTransform.y+     upwards
+             *      hmdTransform.z+     towards the front
+             *
+             *  ivaInitialPosition and ivaInitialRotation are the Unity world coordinates where
+             *  we initialize the VR scene, i.e. the origin of a coordinate system that maps
+             *  1-to-1 with physical space.
+             *
+             *  1. Calculate the position of the eye in the physical coordinate system.
+             *  2. Transform the calculated position into Unity world coordinates, offset from
+             *     ivaInitialPosition and ivaInitialRotation.
+             */
+
+            // position of the eye in the VR reference frame
+            Vector3 positionToEye = hmdTransform.pos + hmdTransform.rot * hmdEyeTransform.pos;
+
+            // position of the eye in the IVA reference frame
+            InternalCamera.Instance.transform.position = ivaInitialPosition + ivaInitialRotation * positionToEye;
+            InternalCamera.Instance.transform.rotation = ivaInitialRotation * hmdTransform.rot;
+
+            // move the FlightCamera to match the position of the InternalCamera (so the outside world moves accordingly)
+            FlightCamera.fetch.transform.position = InternalSpace.InternalToWorld(InternalCamera.Instance.transform.position);
+            FlightCamera.fetch.transform.rotation = InternalSpace.InternalToWorld(InternalCamera.Instance.transform.rotation);
+
+            // render the set of cameras
+            for (int i = 0; i < numCamerasToRender; i++) {
+                CameraProperties camProperties = camerasToRender[i];
+
+                // set projection matrix
+                camProperties.camera.projectionMatrix = (eye == EVREye.Eye_Left) ?
+                    camProperties.hmdLeftProjMatrix : camProperties.hmdRightProjMatrix;
+
+                // set texture to render to, then render
+                camProperties.camera.targetTexture = hmdEyeRenderTexture;
+                camProperties.camera.Render();
+            }
+
+            // Submit frames to HMD
+            EVRCompositorError vrCompositorError = vrCompositor.Submit(eye, ref hmdEyeTexture, ref hmdTextureBounds, EVRSubmitFlags.Submit_Default);
+            if (vrCompositorError != EVRCompositorError.None) {
+                throw new Exception("Submit (" + eye + ") failed: (" + (int)vrCompositorError + ") " + vrCompositorError.ToString());
+            }
+        }
+
         /// <summary>
         /// Overrides the OnDestroy method, called when plugin is destroyed (leaving Flight scene).
         /// </summary>
@@ -188,11 +307,15 @@ public void OnDestroy() {
         }
 
         /// <summary>
-        /// An event called when the game is switching scenes.
+        /// An event called when the game is switching scenes. The VR headset should be disabled.
         /// </summary>
-        /// <param name="data">The scene being switched into.</param>
-        public void OnGameSceneLoadRequested(GameScenes data) {
-            CloseHMD();
+        /// <param name="scene">The scene being switched into.</param>
+        public void OnGameSceneLoadRequested(GameScenes scene) {
+            HmdIsEnabled = false;
+        }
+
+        public void OnGUI() {
+            gui.OnGUI();
         }
 
         /// <summary>
@@ -217,8 +340,7 @@ private bool InitHMD() {
                 return retVal;
             }
 
-            // check if SteamVR runtime is installed.
-            // For this plugin, MAKE SURE IT IS ALREADY RUNNING.
+            // check if SteamVR runtime is installed
             retVal = OpenVR.IsRuntimeInstalled();
             if (!retVal) {
                 Utils.LogError("SteamVR runtime not found on this system.");
@@ -228,8 +350,6 @@ private bool InitHMD() {
             // initialize HMD
             EVRInitError hmdInitErrorCode = EVRInitError.None;
             vrSystem = OpenVR.Init(ref hmdInitErrorCode, EVRApplicationType.VRApplication_Scene);
-
-            // return if failure
             retVal = (hmdInitErrorCode == EVRInitError.None);
             if (!retVal) {
                 Utils.LogError("Failed to initialize HMD. Init returned: " + OpenVR.GetStringForHmdError(hmdInitErrorCode));
@@ -238,7 +358,6 @@ private bool InitHMD() {
 
             // reset "seated position" and capture initial position. this means you should hold the HMD in
             // the position you would like to consider "seated", before running this code.
-
             ResetInitialHmdPosition();
 
             // initialize Compositor
@@ -261,7 +380,7 @@ private bool InitHMD() {
             hmdRightEyeTexture.handle = hmdRightEyeRenderTexture.GetNativeTexturePtr();
             hmdRightEyeTexture.eColorSpace = EColorSpace.Auto;
 
-
+            // at the moment, only Direct3D12 is working with Kerbal Space Program
             switch (SystemInfo.graphicsDeviceType) {
                 case UnityEngine.Rendering.GraphicsDeviceType.OpenGLCore:
                 case UnityEngine.Rendering.GraphicsDeviceType.OpenGLES2:
@@ -280,8 +399,7 @@ private bool InitHMD() {
                     throw (new Exception(SystemInfo.graphicsDeviceType.ToString() + " not supported"));
             }
 
-            // Set rendering bounds on texture to render?
-            // I assume min=0.0 and max=1.0 renders to the full extent of the texture
+            // set rendering bounds on texture to render
             hmdTextureBounds.uMin = 0.0f;
             hmdTextureBounds.uMax = 1.0f;
             hmdTextureBounds.vMin = 1.0f; // flip the vertical coordinate for some reason
@@ -300,73 +418,46 @@ private void InitVRScene() {
             }*/
 
             // search for camera objects to render
-            camerasToRender = new List<CameraProperties>(cameraNames.Length);
-            foreach (string cameraName in cameraNames) {
-                foreach (Camera camera in Camera.allCameras) {
-                    if (cameraName.Equals(camera.name)) {
-                        float nearClipPlane = (camera.name.Equals("Camera 01")) ? 0.05f : camera.nearClipPlane;
-
-                        HmdMatrix44_t projLeft = vrSystem.GetProjectionMatrix(EVREye.Eye_Left, nearClipPlane, camera.farClipPlane);
-                        HmdMatrix44_t projRight = vrSystem.GetProjectionMatrix(EVREye.Eye_Right, nearClipPlane, camera.farClipPlane);
-                        camerasToRender.Add(new CameraProperties(camera, camera.projectionMatrix, MathUtils.Matrix4x4_OpenVr2UnityFormat(ref projLeft), MathUtils.Matrix4x4_OpenVr2UnityFormat(ref projRight)));
-                        break;
-                    }
-                }
-            }
-        }
+            numCamerasToRender = cameraNames.Length;
+            camerasToRender = new CameraProperties[numCamerasToRender];
+            for (int i = 0; i < cameraNames.Length; i++) {
 
-        private void RenderHmdCameras(
-            EVREye eye,
-            SteamVR_Utils.RigidTransform hmdTransform,
-            SteamVR_Utils.RigidTransform hmdEyeTransform,
-            RenderTexture hmdEyeRenderTexture,
-            Texture_t hmdEyeTexture) {
-
-            // rotate camera according to the HMD orientation
-            InternalCamera.Instance.transform.localRotation = hmdTransform.rot;
+                Camera foundCamera = Array.Find(Camera.allCameras, cam => cam.name.Equals(cameraNames[i]));
+                if (foundCamera == null) {
+                    Utils.LogError("Could not find camera \"" + cameraNames[i] + "\" in the scene!");
 
-            // translate the camera to match the position of the left eye, from origin
-            InternalCamera.Instance.transform.localPosition = new Vector3(0f, 0f, 0f);
-            InternalCamera.Instance.transform.Translate(hmdEyeTransform.pos);
+                } else {
 
-            // translate the camera to match the position of the HMD
-            InternalCamera.Instance.transform.localPosition += hmdTransform.pos;
+                    float nearClipPlane = (foundCamera.name.Equals("Camera 01")) ? 0.05f : foundCamera.nearClipPlane;
+                    HmdMatrix44_t projLeft = OpenVR.System.GetProjectionMatrix(EVREye.Eye_Left, nearClipPlane, foundCamera.farClipPlane);
+                    HmdMatrix44_t projRight = OpenVR.System.GetProjectionMatrix(EVREye.Eye_Right, nearClipPlane, foundCamera.farClipPlane);
 
-            // move the FlightCamera to match the position of the InternalCamera (so the outside world moves accordingly)
-            FlightCamera.fetch.transform.position = InternalSpace.InternalToWorld(InternalCamera.Instance.transform.position);
-            FlightCamera.fetch.transform.rotation = InternalSpace.InternalToWorld(InternalCamera.Instance.transform.rotation);
-
-            // render the set of cameras
-            foreach (CameraProperties camStruct in camerasToRender) {
-                // set projection matrix
-                camStruct.camera.projectionMatrix = (eye == EVREye.Eye_Left) ?
-                    camStruct.hmdLeftProjMatrix : camStruct.hmdRightProjMatrix;
-
-                // set texture to render to
-                camStruct.camera.targetTexture = hmdEyeRenderTexture;
-
-                // render camera
-                camStruct.camera.Render();
+                    camerasToRender[i] = new CameraProperties(
+                        foundCamera,
+                        foundCamera.projectionMatrix,
+                        MathUtils.Matrix4x4_OpenVr2UnityFormat(ref projLeft),
+                        MathUtils.Matrix4x4_OpenVr2UnityFormat(ref projRight));
+                }
+                
             }
 
-            // Submit frames to HMD
-            EVRCompositorError vrCompositorError = vrCompositor.Submit(eye, ref hmdEyeTexture, ref hmdTextureBounds, EVRSubmitFlags.Submit_Default);
-            if (vrCompositorError != EVRCompositorError.None) {
-                throw new Exception("Submit (" + eye + ") failed: (" + (int)vrCompositorError + ") " + vrCompositorError.ToString());
-            }
+            // capture the initial viewpoint position
+            ivaInitialPosition = InternalCamera.Instance.transform.position;
+            ivaInitialRotation = InternalCamera.Instance.transform.rotation;
+            
         }
 
         /// <summary>
         /// Sets the current real-world position of the HMD as the seated origin in IVA.
         /// </summary>
-        private void ResetInitialHmdPosition() {
+        public void ResetInitialHmdPosition() {
             if (hmdIsInitialized) {
                 vrSystem.ResetSeatedZeroPose();
             }
         }
 
         private void CloseHMD() {
-            hmdIsEnabled = false;
+            HmdIsEnabled = false;
             OpenVR.Shutdown();
             hmdIsInitialized = false;
         }
diff --git a/KerbalVR/KerbalVR_Utils.cs b/KerbalVR/KerbalVR_Utils.cs
index 60b52cce..dc6b8e04 100644
--- a/KerbalVR/KerbalVR_Utils.cs
+++ b/KerbalVR/KerbalVR_Utils.cs
@@ -1,12 +1,18 @@
-using System;
+using System;
 using System.IO;
 using System.Reflection;
+using System.Runtime.InteropServices;
 using UnityEngine;
+using Valve.VR;
 
 namespace KerbalVR
 {
     class Utils
     {
+        public static readonly string KERBALVR_ASSETS_DIR = "KerbalVR/Assets/";
+
+        private static readonly string LOG_PREFIX = "[KerbalVR] ";
+
         // define location of OpenVR library
         public static string OpenVRDllPath {
             get {
@@ -25,19 +31,144 @@ public static Component GetOrAddComponent<T>(GameObject obj) where T : Component
         }
 
         public static void LogInfo(object obj) {
-            Debug.Log("[KerbalVR] L:: " + obj);
+            Debug.Log(LOG_PREFIX + obj);
         }
 
         public static void LogWarning(object obj) {
-            Debug.LogWarning("[KerbalVR] W@@ " + obj);
+            Debug.LogWarning(LOG_PREFIX + obj);
         }
 
         public static void LogError(object obj) {
-            Debug.LogError("[KerbalVR] E!! " + obj);
+            Debug.LogError(LOG_PREFIX + obj);
         }
 
         public static bool Is64BitProcess {
             get { return (IntPtr.Size == 8); }
         }
+
+        public static GameObject CreateGizmo() {
+            GameObject gizmo = new GameObject("gizmo");
+            gizmo.transform.localScale = Vector3.one;
+
+            GameObject gizmoX = GameObject.CreatePrimitive(PrimitiveType.Cube);
+            UnityEngine.Object.Destroy(gizmoX.GetComponent<BoxCollider>());
+            gizmoX.transform.SetParent(gizmo.transform);
+            gizmoX.transform.localScale = new Vector3(.1f, .01f, .01f);
+            gizmoX.transform.localPosition = new Vector3(.05f, 0f, 0f);
+            gizmoX.GetComponent<MeshRenderer>().material.color = Color.red;
+            gizmoX.layer = 20;
+
+            GameObject gizmoY = GameObject.CreatePrimitive(PrimitiveType.Cube);
+            UnityEngine.Object.Destroy(gizmoY.GetComponent<BoxCollider>());
+            gizmoY.transform.SetParent(gizmo.transform);
+            gizmoY.transform.localScale = new Vector3(.01f, .1f, .01f);
+            gizmoY.transform.localPosition = new Vector3(.0f, .05f, 0f);
+            gizmoY.GetComponent<MeshRenderer>().material.color = Color.green;
+            gizmoY.layer = 20;
+
+            GameObject gizmoZ = GameObject.CreatePrimitive(PrimitiveType.Cube);
+            UnityEngine.Object.Destroy(gizmoZ.GetComponent<BoxCollider>());
+            gizmoZ.transform.SetParent(gizmo.transform);
+            gizmoZ.transform.localScale = new Vector3(.01f, .01f, .1f);
+            gizmoZ.transform.localPosition = new Vector3(.0f, 0f, .05f);
+            gizmoZ.GetComponent<MeshRenderer>().material.color = Color.blue;
+            gizmoZ.layer = 20;
+
+            GameObject gizmoPivot = GameObject.CreatePrimitive(PrimitiveType.Sphere);
+            UnityEngine.Object.Destroy(gizmoPivot.GetComponent<SphereCollider>());
+            gizmoPivot.transform.SetParent(gizmo.transform);
+            gizmoPivot.transform.localScale = new Vector3(.02f, .02f, .02f);
+            gizmoPivot.transform.localPosition = Vector3.zero;
+            gizmoPivot.GetComponent<MeshRenderer>().material.color = Color.gray;
+            gizmoPivot.layer = 20;
+
+            return gizmo;
+        }
+
+        public static GameObject CreateGizmoAtPosition(Transform location) {
+            return CreateGizmoAtPosition(location.position, location.rotation);
+        }
+
+        public static GameObject CreateGizmoAtPosition(Vector3 position) {
+            return CreateGizmoAtPosition(position, Quaternion.identity);
+        }
+
+        public static GameObject CreateGizmoAtPosition(Vector3 position, Quaternion rotation) {
+            GameObject gizmo = CreateGizmo();
+            gizmo.transform.position = position;
+            gizmo.transform.rotation = rotation;
+            return gizmo;
+        }
+
+        public static Mesh CreateHiddenAreaMesh(HiddenAreaMesh_t src, VRTextureBounds_t bounds) {
+            if (src.unTriangleCount == 0)
+                return null;
+
+            var data = new float[src.unTriangleCount * 3 * 2]; //HmdVector2_t
+            Marshal.Copy(src.pVertexData, data, 0, data.Length);
+
+            var vertices = new Vector3[src.unTriangleCount * 3 + 12];
+            var indices = new int[src.unTriangleCount * 3 + 24];
+
+            var x0 = 2.0f * bounds.uMin - 1.0f;
+            var x1 = 2.0f * bounds.uMax - 1.0f;
+            var y0 = 2.0f * bounds.vMin - 1.0f;
+            var y1 = 2.0f * bounds.vMax - 1.0f;
+
+            for (int i = 0, j = 0; i < src.unTriangleCount * 3; i++) {
+                var x = SteamVR_Utils.Lerp(x0, x1, data[j++]);
+                var y = SteamVR_Utils.Lerp(y0, y1, data[j++]);
+                vertices[i] = new Vector3(x, y, 0.0f);
+                indices[i] = i;
+            }
+
+            // Add border
+            var offset = (int)src.unTriangleCount * 3;
+            var iVert = offset;
+            vertices[iVert++] = new Vector3(-1, -1, 0);
+            vertices[iVert++] = new Vector3(x0, -1, 0);
+            vertices[iVert++] = new Vector3(-1, 1, 0);
+            vertices[iVert++] = new Vector3(x0, 1, 0);
+            vertices[iVert++] = new Vector3(x1, -1, 0);
+            vertices[iVert++] = new Vector3(1, -1, 0);
+            vertices[iVert++] = new Vector3(x1, 1, 0);
+            vertices[iVert++] = new Vector3(1, 1, 0);
+            vertices[iVert++] = new Vector3(x0, y0, 0);
+            vertices[iVert++] = new Vector3(x1, y0, 0);
+            vertices[iVert++] = new Vector3(x0, y1, 0);
+            vertices[iVert++] = new Vector3(x1, y1, 0);
+
+            var iTri = offset;
+            indices[iTri++] = offset + 0;
+            indices[iTri++] = offset + 1;
+            indices[iTri++] = offset + 2;
+            indices[iTri++] = offset + 2;
+            indices[iTri++] = offset + 1;
+            indices[iTri++] = offset + 3;
+            indices[iTri++] = offset + 4;
+            indices[iTri++] = offset + 5;
+            indices[iTri++] = offset + 6;
+            indices[iTri++] = offset + 6;
+            indices[iTri++] = offset + 5;
+            indices[iTri++] = offset + 7;
+            indices[iTri++] = offset + 1;
+            indices[iTri++] = offset + 4;
+            indices[iTri++] = offset + 8;
+            indices[iTri++] = offset + 8;
+            indices[iTri++] = offset + 4;
+            indices[iTri++] = offset + 9;
+            indices[iTri++] = offset + 10;
+            indices[iTri++] = offset + 11;
+            indices[iTri++] = offset + 3;
+            indices[iTri++] = offset + 3;
+            indices[iTri++] = offset + 11;
+            indices[iTri++] = offset + 6;
+
+            var mesh = new Mesh();
+            mesh.vertices = vertices;
+            mesh.triangles = indices;
+            mesh.bounds = new Bounds(Vector3.zero, new Vector3(float.MaxValue, float.MaxValue, float.MaxValue)); // Prevent frustum culling from culling this mesh
+            return mesh;
+        }
     }
 }
diff --git a/KerbalVR/Properties/AssemblyInfo.cs b/KerbalVR/Properties/AssemblyInfo.cs
index ffca8d23..cba3a541 100644
--- a/KerbalVR/Properties/AssemblyInfo.cs
+++ b/KerbalVR/Properties/AssemblyInfo.cs
@@ -32,4 +32,4 @@
 // You can specify all the values or you can default the Build and Revision Numbers 
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("2.1.0.*")]
+[assembly: AssemblyVersion("2.2.0.*")]