moar test

RhythmKata/Assets/Scripts/Player/InputTest.cs

@@ -2,35 +2,34 @@
 using System.Collections.Generic;
 using UnityEngine;
 using UnityEngine.InputSystem;
+using Valve.VR;
 
 public class InputTest : MonoBehaviour
 {
-    PlayerInputAction input;
-
+    // a reference to the action
+    public SteamVR_Action_Boolean fire;
+    // a reference to the hand
+    public SteamVR_Input_Sources handType;
     public void Awake()
     {
-        input = new PlayerInputAction();
 
-        input.Player.FireL.performed += ctx => OnFireL(ctx);
-        input.Player.FireR.performed += ctx => OnFireR(ctx);
-    }
-    public void OnFireL(InputAction.CallbackContext context)
-    {
-        Debug.Log(context.time);
+        fire.AddOnStateDownListener(OnFireL, handType);
     }
 
-    public void OnFireR(InputAction.CallbackContext context)
+    public void Update()
     {
+        //for (int i = 0; i < 10000000; i++)
+        //{
 
+        //}
     }
-
-    public void OnEnable()
+    public void OnFireL(SteamVR_Action_Boolean fromAction, SteamVR_Input_Sources fromSource)
     {
-        input.Enable();
+        Debug.Log(string.Format("current: {0}\t input: {1}\t rotation:{2}", fromAction.changedTime, Time.time, 0));
     }
 
-    public void OnDisable()
+    public void OnFireR(InputAction.CallbackContext context)
     {
-        input.Disable();
+
     }
 }

RhythmKata/Assets/Scripts/Player/PlayerInput.inputactions

 {
-    "name": "RhythmKata",
+    "name": "PlayerInput",
     "maps": [
         {
             "name": "Player",
             "id": "4d2c4dbc-fc03-4738-8c83-3e3b367db3b9",
             "actions": [
-                {
-                    "name": "Move",
-                    "type": "Value",
-                    "id": "a5a44c93-8f67-4f54-b3a1-dc45319a4a6e",
-                    "expectedControlType": "Vector2",
-                    "processors": "",
-                    "interactions": ""
-                },
                 {
                     "name": "Look",
                     "type": "Value",
@@ -36,130 +28,17 @@
                     "expectedControlType": "Button",
                     "processors": "",
                     "interactions": ""
-                }
-            ],
-            "bindings": [
-                {
-                    "name": "",
-                    "id": "978bfe49-cc26-4a3d-ab7b-7d7a29327403",
-                    "path": "<Gamepad>/leftStick",
-                    "interactions": "",
-                    "processors": "",
-                    "groups": ";Gamepad",
-                    "action": "Move",
-                    "isComposite": false,
-                    "isPartOfComposite": false
-                },
-                {
-                    "name": "WASD",
-                    "id": "00ca640b-d935-4593-8157-c05846ea39b3",
-                    "path": "Dpad",
-                    "interactions": "",
-                    "processors": "",
-                    "groups": "",
-                    "action": "Move",
-                    "isComposite": true,
-                    "isPartOfComposite": false
-                },
-                {
-                    "name": "up",
-                    "id": "e2062cb9-1b15-46a2-838c-2f8d72a0bdd9",
-                    "path": "<Keyboard>/w",
-                    "interactions": "",
-                    "processors": "",
-                    "groups": ";Keyboard&Mouse",
-                    "action": "Move",
-                    "isComposite": false,
-                    "isPartOfComposite": true
-                },
-                {
-                    "name": "down",
-                    "id": "320bffee-a40b-4347-ac70-c210eb8bc73a",
-                    "path": "<Keyboard>/s",
-                    "interactions": "",
-                    "processors": "",
-                    "groups": ";Keyboard&Mouse",
-                    "action": "Move",
-                    "isComposite": false,
-                    "isPartOfComposite": true
                 },
                 {
-                    "name": "left",
-                    "id": "d2581a9b-1d11-4566-b27d-b92aff5fabbc",
-                    "path": "<Keyboard>/a",
-                    "interactions": "",
-                    "processors": "",
-                    "groups": ";Keyboard&Mouse",
-                    "action": "Move",
-                    "isComposite": false,
-                    "isPartOfComposite": true
-                },
-                {
-                    "name": "right",
-                    "id": "fcfe95b8-67b9-4526-84b5-5d0bc98d6400",
-                    "path": "<Keyboard>/d",
-                    "interactions": "",
-                    "processors": "",
-                    "groups": ";Keyboard&Mouse",
-                    "action": "Move",
-                    "isComposite": false,
-                    "isPartOfComposite": true
-                },
-                {
-                    "name": "Arrows",
-                    "id": "12911854-7ef9-433a-abf6-8c5b3083e453",
-                    "path": "2DVector",
-                    "interactions": "",
-                    "processors": "",
-                    "groups": "",
-                    "action": "Move",
-                    "isComposite": true,
-                    "isPartOfComposite": false
-                },
-                {
-                    "name": "up",
-                    "id": "7393f231-7340-425a-bc46-e5ed77bce631",
-                    "path": "<Keyboard>/upArrow",
-                    "interactions": "",
-                    "processors": "",
-                    "groups": ";Keyboard&Mouse",
-                    "action": "Move",
-                    "isComposite": false,
-                    "isPartOfComposite": true
-                },
-                {
-                    "name": "down",
-                    "id": "6cbc0fe4-6202-44fa-ab64-513c4b47fc8e",
-                    "path": "<Keyboard>/downArrow",
-                    "interactions": "",
-                    "processors": "",
-                    "groups": ";Keyboard&Mouse",
-                    "action": "Move",
-                    "isComposite": false,
-                    "isPartOfComposite": true
-                },
-                {
-                    "name": "left",
-                    "id": "786944cc-a886-40d2-81a7-05654f07c83c",
-                    "path": "<Keyboard>/leftArrow",
-                    "interactions": "",
-                    "processors": "",
-                    "groups": ";Keyboard&Mouse",
-                    "action": "Move",
-                    "isComposite": false,
-                    "isPartOfComposite": true
-                },
-                {
-                    "name": "right",
-                    "id": "24b2f255-eebe-4388-834e-f3ccde2c559b",
-                    "path": "<Keyboard>/rightArrow",
-                    "interactions": "",
+                    "name": "MoveL",
+                    "type": "Button",
+                    "id": "1d9c9642-9b4a-4cc2-9276-d1fcd33d4280",
+                    "expectedControlType": "",
                     "processors": "",
-                    "groups": ";Keyboard&Mouse",
-                    "action": "Move",
-                    "isComposite": false,
-                    "isPartOfComposite": true
-                },
+                    "interactions": ""
+                }
+            ],
+            "bindings": [
                 {
                     "name": "",
                     "id": "c1f7a91b-d0fd-4a62-997e-7fb9b69bf235",
@@ -218,13 +97,24 @@
                 {
                     "name": "",
                     "id": "8c20d3e6-1b83-480c-8a3f-76dbca2620bc",
-                    "path": "<XRController>{RightHand}/primaryButton",
+                    "path": "<OculusTouchController>/primaryButton",
                     "interactions": "",
                     "processors": "",
                     "groups": ";Keyboard&Mouse",
                     "action": "FireR",
                     "isComposite": false,
                     "isPartOfComposite": false
+                },
+                {
+                    "name": "",
+                    "id": "30b227dd-6ad0-4241-b607-d6c52c05e58b",
+                    "path": "",
+                    "interactions": "",
+                    "processors": "",
+                    "groups": "",
+                    "action": "MoveL",
+                    "isComposite": false,
+                    "isPartOfComposite": false
                 }
             ]
         },

RhythmKata/Assets/Level.meta → RhythmKata/Assets/SteamVR.meta

 fileFormatVersion: 2
-guid: 66ac6ee4bb427894bb3caae91e4e7469
+guid: a47b8ffcd65b48649ae2e076cb27d9a0
 folderAsset: yes
 DefaultImporter:
   externalObjects: {}

RhythmKata/Assets/SteamVR/Editor.meta

+fileFormatVersion: 2
+guid: c33af0785775d7548b22541da37936fe
+folderAsset: yes
+DefaultImporter:
+  userData: 
+  assetBundleName: 

RhythmKata/Assets/SteamVR/Editor/SteamVR_AutoEnableVR.cs.meta

+fileFormatVersion: 2
+guid: 359dfd8d7e3732240894f33b6f6d6e56
+timeCreated: 1548371829
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

RhythmKata/Assets/SteamVR/Editor/SteamVR_Editor.asmdef

+{
+    "name": "SteamVR_Editor",
+    "references": [
+        "SteamVR"
+    ],
+    "optionalUnityReferences": [],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": []
+}
\ No newline at end of file

RhythmKata/Assets/SteamVR/Editor/SteamVR_Editor.asmdef.meta

+fileFormatVersion: 2
+guid: 9bac448de04a4f6448fee1acc220e5a1
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

RhythmKata/Assets/SteamVR/Editor/SteamVR_Editor.cs

+//======= Copyright (c) Valve Corporation, All rights reserved. ===============
+//
+// Purpose: Custom inspector display for SteamVR_Camera
+//
+//=============================================================================
+
+using UnityEngine;
+using UnityEditor;
+using System.IO;
+using Valve.VR;
+
+[CustomEditor(typeof(SteamVR_Camera)), CanEditMultipleObjects]
+public class SteamVR_Editor : Editor
+{
+    int bannerHeight = 150;
+    Texture logo;
+
+    SerializedProperty script, wireframe;
+
+    string GetResourcePath()
+    {
+        var ms = MonoScript.FromScriptableObject(this);
+        var path = AssetDatabase.GetAssetPath(ms);
+        path = Path.GetDirectoryName(path);
+        return path.Substring(0, path.Length - "Editor".Length) + "Textures/";
+    }
+
+    void OnEnable()
+    {
+        var resourcePath = GetResourcePath();
+
+        logo = AssetDatabase.LoadAssetAtPath<Texture2D>(resourcePath + "logo.png");
+
+        script = serializedObject.FindProperty("m_Script");
+
+        wireframe = serializedObject.FindProperty("wireframe");
+
+        foreach (SteamVR_Camera target in targets)
+            target.ForceLast();
+    }
+
+    public override void OnInspectorGUI()
+    {
+        serializedObject.Update();
+
+        var rect = GUILayoutUtility.GetRect(Screen.width - 38, bannerHeight, GUI.skin.box);
+        if (logo)
+            GUI.DrawTexture(rect, logo, ScaleMode.ScaleToFit);
+
+        if (!Application.isPlaying)
+        {
+            var expand = false;
+            var collapse = false;
+            foreach (SteamVR_Camera target in targets)
+            {
+                if (AssetDatabase.Contains(target))
+                    continue;
+                if (target.isExpanded)
+                    collapse = true;
+                else
+                    expand = true;
+            }
+
+            if (expand)
+            {
+                GUILayout.BeginHorizontal();
+                if (GUILayout.Button("Expand"))
+                {
+                    foreach (SteamVR_Camera target in targets)
+                    {
+                        if (AssetDatabase.Contains(target))
+                            continue;
+                        if (!target.isExpanded)
+                        {
+                            target.Expand();
+                            EditorUtility.SetDirty(target);
+                        }
+                    }
+                }
+                GUILayout.Space(18);
+                GUILayout.EndHorizontal();
+            }
+
+            if (collapse)
+            {
+                GUILayout.BeginHorizontal();
+                if (GUILayout.Button("Collapse"))
+                {
+                    foreach (SteamVR_Camera target in targets)
+                    {
+                        if (AssetDatabase.Contains(target))
+                            continue;
+                        if (target.isExpanded)
+                        {
+                            target.Collapse();
+                            EditorUtility.SetDirty(target);
+                        }
+                    }
+                }
+                GUILayout.Space(18);
+                GUILayout.EndHorizontal();
+            }
+        }
+
+        EditorGUILayout.PropertyField(script);
+        EditorGUILayout.PropertyField(wireframe);
+
+        serializedObject.ApplyModifiedProperties();
+    }
+
+    public static void ExportPackage()
+    {
+        AssetDatabase.ExportPackage(new string[] {
+            "Assets/SteamVR",
+            "Assets/Plugins/openvr_api.cs",
+            "Assets/Plugins/openvr_api.bundle",
+            "Assets/Plugins/x86/openvr_api.dll",
+            "Assets/Plugins/x86/steam_api.dll",
+            "Assets/Plugins/x86/libsteam_api.so",
+            "Assets/Plugins/x86_64/openvr_api.dll",
+            "Assets/Plugins/x86_64/steam_api.dll",
+            "Assets/Plugins/x86_64/libsteam_api.so",
+            "Assets/Plugins/x86_64/libopenvr_api.so",
+        }, "steamvr.unitypackage", ExportPackageOptions.Recurse);
+        EditorApplication.Exit(0);
+    }
+}
\ No newline at end of file

RhythmKata/Assets/SteamVR/Editor/SteamVR_Editor.cs.meta

+fileFormatVersion: 2
+guid: 5ba22c80948c94e44a82b9fd1b3abd0d
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 

RhythmKata/Assets/SteamVR/Editor/SteamVR_Preferences.cs

+//======= Copyright (c) Valve Corporation, All rights reserved. ===============
+//removed and added to the SteamVR_Settings asset so it can be configured per project
\ No newline at end of file

RhythmKata/Assets/SteamVR/Editor/SteamVR_Preferences.cs.meta

+fileFormatVersion: 2
+guid: 29abf75f7265ccb45b799eac4ab0ca94
+timeCreated: 1487968203
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

RhythmKata/Assets/SteamVR/Editor/SteamVR_RenderModelEditor.cs

+//======= Copyright (c) Valve Corporation, All rights reserved. ===============
+//
+// Purpose: Custom inspector display for SteamVR_RenderModel
+//
+//=============================================================================
+
+using UnityEngine;
+using UnityEditor;
+using System.Text;
+using System.Collections.Generic;
+
+namespace Valve.VR
+{
+    [CustomEditor(typeof(SteamVR_RenderModel)), CanEditMultipleObjects]
+    public class SteamVR_RenderModelEditor : Editor
+    {
+        SerializedProperty script, index, modelOverride, shader, verbose, createComponents, updateDynamically;
+
+        static string[] renderModelNames;
+        int renderModelIndex;
+
+        void OnEnable()
+        {
+            script = serializedObject.FindProperty("m_Script");
+            index = serializedObject.FindProperty("index");
+            modelOverride = serializedObject.FindProperty("modelOverride");
+            shader = serializedObject.FindProperty("shader");
+            verbose = serializedObject.FindProperty("verbose");
+            createComponents = serializedObject.FindProperty("createComponents");
+            updateDynamically = serializedObject.FindProperty("updateDynamically");
+
+            // Load render model names if necessary.
+            if (renderModelNames == null)
+            {
+                renderModelNames = LoadRenderModelNames();
+            }
+
+            // Update renderModelIndex based on current modelOverride value.
+            if (modelOverride.stringValue != "")
+            {
+                for (int i = 0; i < renderModelNames.Length; i++)
+                {
+                    if (modelOverride.stringValue == renderModelNames[i])
+                    {
+                        renderModelIndex = i;
+                        break;
+                    }
+                }
+            }
+        }
+
+        static string[] LoadRenderModelNames()
+        {
+            var results = new List<string>();
+            results.Add("None");
+
+            using (var holder = new SteamVR_RenderModel.RenderModelInterfaceHolder())
+            {
+                var renderModels = holder.instance;
+                if (renderModels != null)
+                {
+                    uint count = renderModels.GetRenderModelCount();
+                    for (uint i = 0; i < count; i++)
+                    {
+                        var buffer = new StringBuilder();
+                        var requiredSize = renderModels.GetRenderModelName(i, buffer, 0);
+                        if (requiredSize == 0)
+                            continue;
+
+                        buffer.EnsureCapacity((int)requiredSize);
+                        renderModels.GetRenderModelName(i, buffer, requiredSize);
+                        results.Add(buffer.ToString());
+                    }
+                }
+            }
+
+            return results.ToArray();
+        }
+
+        public override void OnInspectorGUI()
+        {
+            serializedObject.Update();
+
+            EditorGUILayout.PropertyField(script);
+            EditorGUILayout.PropertyField(index);
+            //EditorGUILayout.PropertyField(modelOverride);
+
+            GUILayout.BeginHorizontal();
+            GUILayout.Label(new GUIContent("Model Override", SteamVR_RenderModel.modelOverrideWarning));
+            var selected = EditorGUILayout.Popup(renderModelIndex, renderModelNames);
+            if (selected != renderModelIndex)
+            {
+                renderModelIndex = selected;
+                modelOverride.stringValue = (selected > 0) ? renderModelNames[selected] : "";
+            }
+            GUILayout.EndHorizontal();
+
+            EditorGUILayout.PropertyField(shader);
+            EditorGUILayout.PropertyField(verbose);
+            EditorGUILayout.PropertyField(createComponents);
+            EditorGUILayout.PropertyField(updateDynamically);
+
+            serializedObject.ApplyModifiedProperties();
+        }
+    }
+}
\ No newline at end of file

RhythmKata/Assets/SteamVR/Editor/SteamVR_RenderModelEditor.cs.meta

+fileFormatVersion: 2
+guid: 67867a20919f7db45a2e7034fda1c28e
+timeCreated: 1433373945
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

RhythmKata/Assets/SteamVR/Editor/SteamVR_SkyboxEditor.cs.meta

+fileFormatVersion: 2
+guid: 80087fbbf7bf93a46bb4aea276b19568
+timeCreated: 1446765449
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

RhythmKata/Assets/SteamVR/Editor/SteamVR_UnitySettingsWindow.cs.meta

+fileFormatVersion: 2
+guid: d2244eee8a3a4784fb40d1123ff69301
+timeCreated: 1438809573
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

RhythmKata/Assets/SteamVR/Editor/SteamVR_Update.cs

+//======= Copyright (c) Valve Corporation, All rights reserved. ===============
+//
+// Purpose: Notify developers when a new version of the plugin is available.
+//
+//=============================================================================
+
+using UnityEngine;
+using UnityEditor;
+using System.IO;
+using System.Text.RegularExpressions;
+
+#if UNITY_2018_3_OR_NEWER
+#pragma warning disable CS0618
+#endif
+
+namespace Valve.VR
+{
+    [InitializeOnLoad]
+    public class SteamVR_Update : EditorWindow
+    {
+        const string currentVersion = "2.1";
+        const string versionUrl = "http://media.steampowered.com/apps/steamvr/unitypluginversion.txt";
+        const string notesUrl = "http://media.steampowered.com/apps/steamvr/unityplugin-v{0}.txt";
+        const string pluginUrl = "http://u3d.as/content/valve-corporation/steam-vr-plugin";
+        const string doNotShowKey = "SteamVR.DoNotShow.v{0}";
+
+        static bool gotVersion = false;
+        static WWW wwwVersion, wwwNotes;
+        static string version, notes;
+        static SteamVR_Update window;
+
+        static SteamVR_Update()
+        {
+            EditorApplication.update += Update;
+        }
+
+        static void Update()
+        {
+            if (!gotVersion)
+            {
+                if (wwwVersion == null)
+                    wwwVersion = new WWW(versionUrl);
+
+                if (!wwwVersion.isDone)
+                    return;
+
+                if (UrlSuccess(wwwVersion))
+                    version = wwwVersion.text;
+
+                wwwVersion = null;
+                gotVersion = true;
+
+                if (ShouldDisplay())
+                {
+                    var url = string.Format(notesUrl, version);
+                    wwwNotes = new WWW(url);
+
+                    window = GetWindow<SteamVR_Update>(true);
+                    window.minSize = new Vector2(320, 440);
+                    //window.title = "SteamVR";
+                }
+            }
+
+            if (wwwNotes != null)
+            {
+                if (!wwwNotes.isDone)
+                    return;
+
+                if (UrlSuccess(wwwNotes))
+                    notes = wwwNotes.text;
+
+                wwwNotes = null;
+
+                if (notes != "")
+                    window.Repaint();
+            }
+
+            EditorApplication.update -= Update;
+        }
+
+        static bool UrlSuccess(WWW www)
+        {
+            if (!string.IsNullOrEmpty(www.error))
+                return false;
+            if (Regex.IsMatch(www.text, "404 not found", RegexOptions.IgnoreCase))
+                return false;
+            return true;
+        }
+
+        static bool ShouldDisplay()
+        {
+            if (string.IsNullOrEmpty(version))
+                return false;
+            if (version == currentVersion)
+                return false;
+            if (EditorPrefs.HasKey(string.Format(doNotShowKey, version)))
+                return false;
+
+            // parse to see if newer (e.g. 1.0.4 vs 1.0.3)
+            var versionSplit = version.Split('.');
+            var currentVersionSplit = currentVersion.Split('.');
+            for (int i = 0; i < versionSplit.Length && i < currentVersionSplit.Length; i++)
+            {
+                int versionValue, currentVersionValue;
+                if (int.TryParse(versionSplit[i], out versionValue) &&
+                    int.TryParse(currentVersionSplit[i], out currentVersionValue))
+                {
+                    if (versionValue > currentVersionValue)
+                        return true;
+                    if (versionValue < currentVersionValue)
+                        return false;
+                }
+            }
+
+            // same up to this point, now differentiate based on number of sub values (e.g. 1.0.4.1 vs 1.0.4)
+            if (versionSplit.Length <= currentVersionSplit.Length)
+                return false;
+
+            return true;
+        }
+
+        Vector2 scrollPosition;
+        bool toggleState;
+
+        string GetResourcePath()
+        {
+            var ms = MonoScript.FromScriptableObject(this);
+            var path = AssetDatabase.GetAssetPath(ms);
+            path = Path.GetDirectoryName(path);
+            return path.Substring(0, path.Length - "Editor".Length) + "Textures/";
+        }
+
+        public void OnGUI()
+        {
+            EditorGUILayout.HelpBox("A new version of the SteamVR plugin is available!", MessageType.Warning);
+
+            var resourcePath = GetResourcePath();
+            var logo = AssetDatabase.LoadAssetAtPath<Texture2D>(resourcePath + "logo.png");
+            var rect = GUILayoutUtility.GetRect(position.width, 150, GUI.skin.box);
+            if (logo)
+                GUI.DrawTexture(rect, logo, ScaleMode.ScaleToFit);
+
+            scrollPosition = GUILayout.BeginScrollView(scrollPosition);
+
+            GUILayout.Label("Current version: " + currentVersion);
+            GUILayout.Label("New version: " + version);
+
+            if (notes != "")
+            {
+                GUILayout.Label("Release notes:");
+                EditorGUILayout.HelpBox(notes, MessageType.Info);
+            }
+
+            GUILayout.EndScrollView();
+
+            GUILayout.FlexibleSpace();
+
+            if (GUILayout.Button("Get Latest Version"))
+            {
+                Application.OpenURL(pluginUrl);
+            }
+
+            EditorGUI.BeginChangeCheck();
+            var doNotShow = GUILayout.Toggle(toggleState, "Do not prompt for this version again.");
+            if (EditorGUI.EndChangeCheck())
+            {
+                toggleState = doNotShow;
+                var key = string.Format(doNotShowKey, version);
+                if (doNotShow)
+                    EditorPrefs.SetBool(key, true);
+                else
+                    EditorPrefs.DeleteKey(key);
+            }
+        }
+    }
+}
+
+#if UNITY_2018_3_OR_NEWER
+#pragma warning restore CS0618
+#endif
\ No newline at end of file

RhythmKata/Assets/SteamVR/Editor/SteamVR_Update.cs.meta

+fileFormatVersion: 2
+guid: 73a0556bda803bf4e898751dcfcf21a8
+timeCreated: 1433880062
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

RhythmKata/Assets/SteamVR/Editor/SteamVR_UpdateModeEditor.cs

+using UnityEditor;
+using UnityEngine;
+
+using System.CodeDom;
+using Microsoft.CSharp;
+using System.IO;
+using System.CodeDom.Compiler;
+
+using System.Linq;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Linq.Expressions;
+using System;
+
+
+namespace Valve.VR
+{
+    [CustomPropertyDrawer(typeof(SteamVR_UpdateModes))]
+    public class SteamVR_UpdateModesEditor : PropertyDrawer
+    {
+        public override void OnGUI(Rect _position, SerializedProperty _property, GUIContent _label)
+        {
+            _property.intValue = EditorGUI.MaskField(_position, _label, _property.intValue, _property.enumNames);
+        }
+    }
+}
\ No newline at end of file

RhythmKata/Assets/SteamVR/Editor/SteamVR_UpdateModeEditor.cs.meta

+fileFormatVersion: 2
+guid: 656e3d05f0a289d4ab6f3d44f65c9b6d
+timeCreated: 1521584981
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

RhythmKata/Assets/SteamVR/Extras.meta

+fileFormatVersion: 2
+guid: 61f4796ee4f00314e8d8b1ad39a78c28
+folderAsset: yes
+timeCreated: 1438797390
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

RhythmKata/Assets/SteamVR/Extras/SteamVR_ForceSteamVRMode.cs

+using UnityEngine;
+using System.Collections;
+
+namespace Valve.VR.Extras
+{
+    /// <summary>
+    /// This is an example class of how to force steamvr initialization. You still need to have vr mode enabled
+    /// but you can have the top sdk set to None, then this script will force it to OpenVR after a second
+    /// </summary>
+    public class SteamVR_ForceSteamVRMode : MonoBehaviour
+    {
+        public GameObject vrCameraPrefab;
+
+        public GameObject[] disableObjectsOnLoad;
+
+        private IEnumerator Start()
+        {
+            yield return new WaitForSeconds(1f); // just here to show that you can wait a while.
+
+            SteamVR.Initialize(true);
+
+            while (SteamVR.initializedState != SteamVR.InitializedStates.InitializeSuccess)
+                yield return null;
+
+            for (int disableIndex = 0; disableIndex < disableObjectsOnLoad.Length; disableIndex++)
+            {
+                GameObject toDisable = disableObjectsOnLoad[disableIndex];
+                if (toDisable != null)
+                    toDisable.SetActive(false);
+            }
+
+            GameObject.Instantiate(vrCameraPrefab);
+        }
+    }
+}
\ No newline at end of file

RhythmKata/Assets/SteamVR/Extras/SteamVR_ForceSteamVRMode.cs.meta

+fileFormatVersion: 2
+guid: c4bc5db9c652ff8408b7cda0197f87f1
+timeCreated: 1539107854
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

RhythmKata/Assets/SteamVR/Extras/SteamVR_ForceSteamVRMode.unity.meta

+fileFormatVersion: 2
+guid: 9b1775e13a163e146930422a18e54bfc
+timeCreated: 1539107812
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

RhythmKata/Assets/SteamVR/Extras/SteamVR_GazeTracker.cs

+//======= Copyright (c) Valve Corporation, All rights reserved. ===============
+using UnityEngine;
+using System.Collections;
+
+namespace Valve.VR.Extras
+{
+    public class SteamVR_GazeTracker : MonoBehaviour
+    {
+        public bool isInGaze = false;
+        public event GazeEventHandler GazeOn;
+        public event GazeEventHandler GazeOff;
+        public float gazeInCutoff = 0.15f;
+        public float gazeOutCutoff = 0.4f;
+
+        // Contains a HMD tracked object that we can use to find the user's gaze
+        protected Transform hmdTrackedObject = null;
+
+        public virtual void OnGazeOn(GazeEventArgs gazeEventArgs)
+        {
+            if (GazeOn != null)
+                GazeOn(this, gazeEventArgs);
+        }
+
+        public virtual void OnGazeOff(GazeEventArgs gazeEventArgs)
+        {
+            if (GazeOff != null)
+                GazeOff(this, gazeEventArgs);
+        }
+
+        protected virtual void Update()
+        {
+            // If we haven't set up hmdTrackedObject find what the user is looking at
+            if (hmdTrackedObject == null)
+            {
+                SteamVR_TrackedObject[] trackedObjects = FindObjectsOfType<SteamVR_TrackedObject>();
+                foreach (SteamVR_TrackedObject tracked in trackedObjects)
+                {
+                    if (tracked.index == SteamVR_TrackedObject.EIndex.Hmd)
+                    {
+                        hmdTrackedObject = tracked.transform;
+                        break;
+                    }
+                }
+            }
+
+            if (hmdTrackedObject)
+            {
+                Ray ray = new Ray(hmdTrackedObject.position, hmdTrackedObject.forward);
+                Plane plane = new Plane(hmdTrackedObject.forward, transform.position);
+
+                float enter = 0.0f;
+                if (plane.Raycast(ray, out enter))
+                {
+                    Vector3 intersect = hmdTrackedObject.position + hmdTrackedObject.forward * enter;
+                    float dist = Vector3.Distance(intersect, transform.position);
+                    //Debug.Log("Gaze dist = " + dist);
+                    if (dist < gazeInCutoff && !isInGaze)
+                    {
+                        isInGaze = true;
+                        GazeEventArgs gazeEventArgs;
+                        gazeEventArgs.distance = dist;
+                        OnGazeOn(gazeEventArgs);
+                    }
+                    else if (dist >= gazeOutCutoff && isInGaze)
+                    {
+                        isInGaze = false;
+                        GazeEventArgs gazeEventArgs;
+                        gazeEventArgs.distance = dist;
+                        OnGazeOff(gazeEventArgs);
+                    }
+                }
+
+            }
+
+        }
+    }
+    public struct GazeEventArgs
+    {
+        public float distance;
+    }
+
+    public delegate void GazeEventHandler(object sender, GazeEventArgs gazeEventArgs);
+}
\ No newline at end of file

RhythmKata/Assets/SteamVR/Extras/SteamVR_GazeTracker.cs.meta

+fileFormatVersion: 2
+guid: 501eb8b744f73714fbe7dbdd5e3ef66e
+timeCreated: 1426193800
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

RhythmKata/Assets/SteamVR/Extras/SteamVR_LaserPointer.cs

+//======= Copyright (c) Valve Corporation, All rights reserved. ===============
+using UnityEngine;
+using System.Collections;
+
+namespace Valve.VR.Extras
+{
+    public class SteamVR_LaserPointer : MonoBehaviour
+    {
+        public SteamVR_Behaviour_Pose pose;
+
+        //public SteamVR_Action_Boolean interactWithUI = SteamVR_Input.__actions_default_in_InteractUI;
+        public SteamVR_Action_Boolean interactWithUI = SteamVR_Input.GetBooleanAction("InteractUI");
+
+        public bool active = true;
+        public Color color;
+        public float thickness = 0.002f;
+        public Color clickColor = Color.green;
+        public GameObject holder;
+        public GameObject pointer;
+        bool isActive = false;
+        public bool addRigidBody = false;
+        public Transform reference;
+        public event PointerEventHandler PointerIn;
+        public event PointerEventHandler PointerOut;
+        public event PointerEventHandler PointerClick;
+
+        Transform previousContact = null;
+
+
+        private void Start()
+        {
+            if (pose == null)
+                pose = this.GetComponent<SteamVR_Behaviour_Pose>();
+            if (pose == null)
+                Debug.LogError("No SteamVR_Behaviour_Pose component found on this object");
+
+            if (interactWithUI == null)
+                Debug.LogError("No ui interaction action has been set on this component.");
+
+
+            holder = new GameObject();
+            holder.transform.parent = this.transform;
+            holder.transform.localPosition = Vector3.zero;
+            holder.transform.localRotation = Quaternion.identity;
+
+            pointer = GameObject.CreatePrimitive(PrimitiveType.Cube);
+            pointer.transform.parent = holder.transform;
+            pointer.transform.localScale = new Vector3(thickness, thickness, 100f);
+            pointer.transform.localPosition = new Vector3(0f, 0f, 50f);
+            pointer.transform.localRotation = Quaternion.identity;
+            BoxCollider collider = pointer.GetComponent<BoxCollider>();
+            if (addRigidBody)
+            {
+                if (collider)
+                {
+                    collider.isTrigger = true;
+                }
+                Rigidbody rigidBody = pointer.AddComponent<Rigidbody>();
+                rigidBody.isKinematic = true;
+            }
+            else
+            {
+                if (collider)
+                {
+                    Object.Destroy(collider);
+                }
+            }
+            Material newMaterial = new Material(Shader.Find("Unlit/Color"));
+            newMaterial.SetColor("_Color", color);
+            pointer.GetComponent<MeshRenderer>().material = newMaterial;
+        }
+
+        public virtual void OnPointerIn(PointerEventArgs e)
+        {
+            if (PointerIn != null)
+                PointerIn(this, e);
+        }
+
+        public virtual void OnPointerClick(PointerEventArgs e)
+        {
+            if (PointerClick != null)
+                PointerClick(this, e);
+        }
+
+        public virtual void OnPointerOut(PointerEventArgs e)
+        {
+            if (PointerOut != null)
+                PointerOut(this, e);
+        }
+
+
+        private void Update()
+        {
+            if (!isActive)
+            {
+                isActive = true;
+                this.transform.GetChild(0).gameObject.SetActive(true);
+            }
+
+            float dist = 100f;
+
+            Ray raycast = new Ray(transform.position, transform.forward);
+            RaycastHit hit;
+            bool bHit = Physics.Raycast(raycast, out hit);
+
+            if (previousContact && previousContact != hit.transform)
+            {
+                PointerEventArgs args = new PointerEventArgs();
+                args.fromInputSource = pose.inputSource;
+                args.distance = 0f;
+                args.flags = 0;
+                args.target = previousContact;
+                OnPointerOut(args);
+                previousContact = null;
+            }
+            if (bHit && previousContact != hit.transform)
+            {
+                PointerEventArgs argsIn = new PointerEventArgs();
+                argsIn.fromInputSource = pose.inputSource;
+                argsIn.distance = hit.distance;
+                argsIn.flags = 0;
+                argsIn.target = hit.transform;
+                OnPointerIn(argsIn);
+                previousContact = hit.transform;
+            }
+            if (!bHit)
+            {
+                previousContact = null;
+            }
+            if (bHit && hit.distance < 100f)
+            {
+                dist = hit.distance;
+            }
+
+            if (bHit && interactWithUI.GetStateUp(pose.inputSource))
+            {
+                PointerEventArgs argsClick = new PointerEventArgs();
+                argsClick.fromInputSource = pose.inputSource;
+                argsClick.distance = hit.distance;
+                argsClick.flags = 0;
+                argsClick.target = hit.transform;
+                OnPointerClick(argsClick);
+            }
+
+            if (interactWithUI != null && interactWithUI.GetState(pose.inputSource))
+            {
+                pointer.transform.localScale = new Vector3(thickness * 5f, thickness * 5f, dist);
+                pointer.GetComponent<MeshRenderer>().material.color = clickColor;
+            }
+            else
+            {
+                pointer.transform.localScale = new Vector3(thickness, thickness, dist);
+                pointer.GetComponent<MeshRenderer>().material.color = color;
+            }
+            pointer.transform.localPosition = new Vector3(0f, 0f, dist / 2f);
+        }
+    }
+
+    public struct PointerEventArgs
+    {
+        public SteamVR_Input_Sources fromInputSource;
+        public uint flags;
+        public float distance;
+        public Transform target;
+    }
+
+    public delegate void PointerEventHandler(object sender, PointerEventArgs e);
+}
\ No newline at end of file

RhythmKata/Assets/SteamVR/Extras/SteamVR_LaserPointer.cs.meta

+fileFormatVersion: 2
+guid: b2f511c1adaa1e94ebe7ca97bbcabd17
+timeCreated: 1539298734
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

RhythmKata/Assets/SteamVR/Extras/SteamVR_LaserPointer.unity.meta

+fileFormatVersion: 2
+guid: f2343db151bc3864e9088f8e4230cdc1
+timeCreated: 1539298758
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

RhythmKata/Assets/SteamVR/Extras/SteamVR_ShowTrackingReferences.unity.meta

+fileFormatVersion: 2
+guid: 73743b10c3912094a8a17bc7ac370c15
+timeCreated: 1550629235
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

RhythmKata/Assets/SteamVR/Extras/SteamVR_TestIK.unity.meta

+fileFormatVersion: 2
+guid: 4b6669fb4e4df9c48926f02b694be9d1
+timeCreated: 1437433018
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

RhythmKata/Assets/SteamVR/Extras/SteamVR_TestThrow.cs

+//======= Copyright (c) Valve Corporation, All rights reserved. ===============
+using UnityEngine;
+using System.Collections;
+
+namespace Valve.VR.Extras
+{
+    [RequireComponent(typeof(SteamVR_TrackedObject))]
+    public class SteamVR_TestThrow : MonoBehaviour
+    {
+        public GameObject prefab;
+        public Rigidbody attachPoint;
+
+        public SteamVR_Action_Boolean spawn = SteamVR_Input.GetAction<SteamVR_Action_Boolean>("InteractUI");
+
+        SteamVR_Behaviour_Pose trackedObj;
+        FixedJoint joint;
+
+        private void Awake()
+        {
+            trackedObj = GetComponent<SteamVR_Behaviour_Pose>();
+        }
+
+        private void FixedUpdate()
+        {
+            if (joint == null && spawn.GetStateDown(trackedObj.inputSource))
+            {
+                GameObject go = GameObject.Instantiate(prefab);
+                go.transform.position = attachPoint.transform.position;
+
+                joint = go.AddComponent<FixedJoint>();
+                joint.connectedBody = attachPoint;
+            }
+            else if (joint != null && spawn.GetStateUp(trackedObj.inputSource))
+            {
+                GameObject go = joint.gameObject;
+                Rigidbody rigidbody = go.GetComponent<Rigidbody>();
+                Object.DestroyImmediate(joint);
+                joint = null;
+                Object.Destroy(go, 15.0f);
+
+                // We should probably apply the offset between trackedObj.transform.position
+                // and device.transform.pos to insert into the physics sim at the correct
+                // location, however, we would then want to predict ahead the visual representation
+                // by the same amount we are predicting our render poses.
+
+                Transform origin = trackedObj.origin ? trackedObj.origin : trackedObj.transform.parent;
+                if (origin != null)
+                {
+                    rigidbody.velocity = origin.TransformVector(trackedObj.GetVelocity());
+                    rigidbody.angularVelocity = origin.TransformVector(trackedObj.GetAngularVelocity());
+                }
+                else
+                {
+                    rigidbody.velocity = trackedObj.GetVelocity();
+                    rigidbody.angularVelocity = trackedObj.GetAngularVelocity();
+                }
+
+                rigidbody.maxAngularVelocity = rigidbody.angularVelocity.magnitude;
+            }
+        }
+    }
+}
\ No newline at end of file

RhythmKata/Assets/SteamVR/Extras/SteamVR_TestThrow.cs.meta

+fileFormatVersion: 2
+guid: ff4f36585e15b1942827390ff1a92502
+timeCreated: 1437513988
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

RhythmKata/Assets/SteamVR/Extras/SteamVR_TestThrow.unity.meta

+fileFormatVersion: 2
+guid: 0d936163b5e9a5047b5e4ba5afaf5126
+timeCreated: 1437513966
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

RhythmKata/Assets/SteamVR/Extras/SteamVR_TestTrackedCamera.cs

+//======= Copyright (c) Valve Corporation, All rights reserved. ===============
+using UnityEngine;
+
+namespace Valve.VR.Extras
+{
+    public class SteamVR_TestTrackedCamera : MonoBehaviour
+    {
+        public Material material;
+        public Transform target;
+        public bool undistorted = true;
+        public bool cropped = true;
+
+        private void OnEnable()
+        {
+            // The video stream must be symmetrically acquired and released in
+            // order to properly disable the stream once there are no consumers.
+            SteamVR_TrackedCamera.VideoStreamTexture source = SteamVR_TrackedCamera.Source(undistorted);
+            source.Acquire();
+
+            // Auto-disable if no camera is present.
+            if (!source.hasCamera)
+                enabled = false;
+        }
+
+        private void OnDisable()
+        {
+            // Clear the texture when no longer active.
+            material.mainTexture = null;
+
+            // The video stream must be symmetrically acquired and released in
+            // order to properly disable the stream once there are no consumers.
+            SteamVR_TrackedCamera.VideoStreamTexture source = SteamVR_TrackedCamera.Source(undistorted);
+            source.Release();
+        }
+
+        private void Update()
+        {
+            SteamVR_TrackedCamera.VideoStreamTexture source = SteamVR_TrackedCamera.Source(undistorted);
+            Texture2D texture = source.texture;
+            if (texture == null)
+            {
+                return;
+            }
+
+            // Apply the latest texture to the material.  This must be performed
+            // every frame since the underlying texture is actually part of a ring
+            // buffer which is updated in lock-step with its associated pose.
+            // (You actually really only need to call any of the accessors which
+            // internally call Update on the SteamVR_TrackedCamera.VideoStreamTexture).
+            material.mainTexture = texture;
+
+            // Adjust the height of the quad based on the aspect to keep the texels square.
+            float aspect = (float)texture.width / texture.height;
+
+            // The undistorted video feed has 'bad' areas near the edges where the original
+            // square texture feed is stretched to undo the fisheye from the lens.
+            // Therefore, you'll want to crop it to the specified frameBounds to remove this.
+            if (cropped)
+            {
+                VRTextureBounds_t bounds = source.frameBounds;
+                material.mainTextureOffset = new Vector2(bounds.uMin, bounds.vMin);
+
+                float du = bounds.uMax - bounds.uMin;
+                float dv = bounds.vMax - bounds.vMin;
+                material.mainTextureScale = new Vector2(du, dv);
+
+                aspect *= Mathf.Abs(du / dv);
+            }
+            else
+            {
+                material.mainTextureOffset = Vector2.zero;
+                material.mainTextureScale = new Vector2(1, -1);
+            }
+
+            target.localScale = new Vector3(1, 1.0f / aspect, 1);
+
+            // Apply the pose that this frame was recorded at.
+            if (source.hasTracking)
+            {
+                SteamVR_Utils.RigidTransform rigidTransform = source.transform;
+                target.localPosition = rigidTransform.pos;
+                target.localRotation = rigidTransform.rot;
+            }
+        }
+    }
+}
\ No newline at end of file

RhythmKata/Assets/SteamVR/Extras/SteamVR_TestTrackedCamera.cs.meta

+fileFormatVersion: 2
+guid: 8b18b36a995ecb04599f35c2741be8d5
+timeCreated: 1465946679
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

RhythmKata/Assets/SteamVR/Extras/SteamVR_TestTrackedCamera.mat.meta

+fileFormatVersion: 2
+guid: 99ee8d48ccf36264e9d9a72baa681249
+timeCreated: 1465950289
+licenseType: Store
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

RhythmKata/Assets/SteamVR/Extras/SteamVR_TestTrackedCamera.unity.meta

+fileFormatVersion: 2
+guid: 7fb811b0ffe615b4dbf1d5e6ced385fd
+timeCreated: 1464227836
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

RhythmKata/Assets/SteamVR/Icon.meta

+fileFormatVersion: 2
+guid: 37d1a399d1ea2d24c8f27e07036b83fb
+folderAsset: yes
+timeCreated: 1532646714
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

RhythmKata/Assets/SteamVR/Input.meta

+fileFormatVersion: 2
+guid: 034ad660702976d4da58a18ccae19443
+folderAsset: yes
+timeCreated: 1521243381
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

RhythmKata/Assets/SteamVR/Input/BehaviourUnityEvents.meta

+fileFormatVersion: 2
+guid: 353612abd09de3a478236e679e220759
+folderAsset: yes
+timeCreated: 1548282626
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

RhythmKata/Assets/SteamVR/Input/BehaviourUnityEvents/SteamVR_Behaviour_BooleanEvent.cs

+//======= Copyright (c) Valve Corporation, All rights reserved. ===============
+using System;
+using UnityEngine.Events;
+
+namespace Valve.VR
+{
+    [Serializable]
+    public class SteamVR_Behaviour_BooleanEvent : UnityEvent<SteamVR_Behaviour_Boolean, SteamVR_Input_Sources, bool> { }
+}
\ No newline at end of file

RhythmKata/Assets/SteamVR/Input/BehaviourUnityEvents/SteamVR_Behaviour_BooleanEvent.cs.meta

+fileFormatVersion: 2
+guid: 59250d64a1ce9a44891e9bb0b3d71e6b
+timeCreated: 1548282626
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

RhythmKata/Assets/SteamVR/Input/BehaviourUnityEvents/SteamVR_Behaviour_PoseEvent.cs

+//======= Copyright (c) Valve Corporation, All rights reserved. ===============
+
+using System;
+using UnityEngine.Events;
+
+namespace Valve.VR
+{
+    [Serializable]
+    public class SteamVR_Behaviour_PoseEvent : UnityEvent<SteamVR_Behaviour_Pose, SteamVR_Input_Sources> { }
+}
\ No newline at end of file

RhythmKata/Assets/SteamVR/Input/Editor/SteamVR_Input_Action_PropertyEditor.cs

+// removed
\ No newline at end of file