private void Dispose(bool disposing)
{
SteamVR_Events.Initializing.Remove(OnInitializing);
SteamVR_Events.Calibrating.Remove(OnCalibrating);
SteamVR_Events.OutOfRange.Remove(OnOutOfRange);
SteamVR_Events.DeviceConnected.Remove(OnDeviceConnected);
SteamVR_Events.NewPoses.Remove(OnNewPoses);
_instance = null;
}
private void OnEnable()
{
SteamVR instance = SteamVR.instance;
if (instance == null)
{
if (this.head != null)
{
this.head.GetComponent <SteamVR_GameView>().enabled = false;
this.head.GetComponent <SteamVR_TrackedObject>().enabled = false;
}
if (this.flip != null)
{
this.flip.enabled = false;
}
base.enabled = false;
return;
}
this.Expand();
if (SteamVR_Camera.blitMaterial == null)
{
SteamVR_Camera.blitMaterial = new Material(VRShaders.GetShader(VRShaders.VRShader.blit));
}
Camera component = base.GetComponent <Camera>();
component.fieldOfView = instance.fieldOfView;
component.aspect = instance.aspect;
component.eventMask = 0;
component.orthographic = false;
component.enabled = false;
if (component.actualRenderingPath != RenderingPath.Forward && QualitySettings.antiAliasing > 1)
{
Debug.LogWarning("MSAA only supported in Forward rendering path. (disabling MSAA)");
QualitySettings.antiAliasing = 0;
}
Camera component2 = this.head.GetComponent <Camera>();
if (component2 != null)
{
component2.renderingPath = component.renderingPath;
}
if (this.ears == null)
{
SteamVR_Ears componentInChildren = base.transform.GetComponentInChildren <SteamVR_Ears>();
if (componentInChildren != null)
{
this._ears = componentInChildren.transform;
}
}
if (this.ears != null)
{
this.ears.GetComponent <SteamVR_Ears>().vrcam = this;
}
SteamVR_Render.Add(this);
}
private static string GetClassPath()
{
string path = Path.Combine(SteamVR.GetSteamVRFolderParentPath(), SteamVR_Settings.instance.steamVRInputPath);
if (Directory.Exists(path) == false)
{
Directory.CreateDirectory(path);
}
return(path);
}
public void InitializeSteamVR(bool forceUnityVRToOpenVR = false)
{
if (forceUnityVRToOpenVR)
{
throw new System.Exception("This should not be used");
}
else
{
SteamVR.Initialize(false);
}
}
protected virtual void OnEnable()
{
SteamVR.Initialize();
if (poseAction != null)
{
poseAction[inputSource].onUpdate += SteamVR_Behaviour_Pose_OnUpdate;
poseAction[inputSource].onDeviceConnectedChanged += OnDeviceConnectedChanged;
poseAction[inputSource].onTrackingChanged += OnTrackingChanged;
poseAction[inputSource].onChange += SteamVR_Behaviour_Pose_OnChange;
}
}
private void OpenControllerBindings()
{
if (HasBeenModified())
{
bool saveFirst = EditorUtility.DisplayDialog("Save?", "It looks like you've made changes without saving. Would you like to save before editing the bindings?.", "Save", "Open without saving");
if (saveFirst)
{
SaveFile();
}
}
SteamVR.ShowBindingsForEditor();
}
/// <summary>
/// Returns an array of positions/rotations that represent the state of each bone in a reference pose.
/// </summary>
/// <param name="referencePose">Which reference pose to return</param>
public void ForceToReferencePose(EVRSkeletalReferencePose referencePose)
{
bool temporarySession = false;
if (Application.isEditor && Application.isPlaying == false)
{
temporarySession = SteamVR.InitializeTemporarySession(true);
Awake();
skeletonAction.actionSet.Activate();
SteamVR_ActionSet_Manager.UpdateActionStates(true);
skeletonAction.UpdateValueWithoutEvents();
}
if (skeletonAction.active == false)
{
Debug.LogError("<b>[SteamVR_Standalone Input]</b> Please turn on your " + inputSource.ToString() + " controller and ensure SteamVR_Standalone is open.", this);
return;
}
SteamVR_Utils.RigidTransform[] transforms = skeletonAction.GetReferenceTransforms(EVRSkeletalTransformSpace.Parent, referencePose);
if (transforms == null || transforms.Length == 0)
{
Debug.LogError("<b>[SteamVR_Standalone Input]</b> Unable to get the reference transform for " + inputSource.ToString() + ". Please make sure SteamVR_Standalone is open and both controllers are connected.", this);
}
if (mirroring == MirrorType.LeftToRight || mirroring == MirrorType.RightToLeft)
{
for (int boneIndex = 0; boneIndex < transforms.Length; boneIndex++)
{
bones[boneIndex].localPosition = MirrorPosition(boneIndex, transforms[boneIndex].pos);
bones[boneIndex].localRotation = MirrorRotation(boneIndex, transforms[boneIndex].rot);
}
}
else
{
for (int boneIndex = 0; boneIndex < transforms.Length; boneIndex++)
{
bones[boneIndex].localPosition = transforms[boneIndex].pos;
bones[boneIndex].localRotation = transforms[boneIndex].rot;
}
}
if (temporarySession)
{
SteamVR.ExitTemporarySession();
}
}
protected virtual void Awake()
{
SteamVR.Initialize();
AssignBonesArray();
proximals = new Transform[] { thumbProximal, indexProximal, middleProximal, ringProximal, pinkyProximal };
middles = new Transform[] { thumbMiddle, indexMiddle, middleMiddle, ringMiddle, pinkyMiddle };
distals = new Transform[] { thumbDistal, indexDistal, middleDistal, ringDistal, pinkyDistal };
tips = new Transform[] { thumbTip, indexTip, middleTip, ringTip, pinkyTip };
auxs = new Transform[] { thumbAux, indexAux, middleAux, ringAux, pinkyAux };
CheckSkeletonAction();
}
private IEnumerator RenderLoop()
{
while (Application.isPlaying)
{
yield return(this.waitForEndOfFrame);
if (!SteamVR_Render.pauseRendering)
{
CVRCompositor compositor = OpenVR.Compositor;
if (compositor != null)
{
if (!compositor.CanRenderScene() || cameras.Length < 1)
{
continue;
}
compositor.SetTrackingSpace(SteamVR.settings.trackingSpace);
SteamVR_Utils.QueueEventOnRenderThread(201510020);
SteamVR.Unity.EventWriteString("[UnityMain] GetNativeTexturePtr - Begin");
SteamVR_Camera.GetSceneTexture(this.cameras[0].GetComponent <Camera>()).GetNativeTexturePtr();
SteamVR.Unity.EventWriteString("[UnityMain] GetNativeTexturePtr - End");
compositor.GetLastPoses(this.poses, this.gamePoses);
SteamVR_Events.NewPoses.Send(this.poses);
SteamVR_Events.NewPosesApplied.Send();
}
SteamVR_Overlay instance = SteamVR_Overlay.instance;
if (instance != null)
{
instance.UpdateOverlay();
}
if (this.CheckExternalCamera())
{
this.RenderExternalCamera();
}
SteamVR instance2 = SteamVR.instance;
this.RenderEye(instance2, EVREye.Eye_Left);
this.RenderEye(instance2, EVREye.Eye_Right);
foreach (SteamVR_Camera steamVR_Camera in this.cameras)
{
steamVR_Camera.transform.localPosition = Vector3.zero;
steamVR_Camera.transform.localRotation = Quaternion.identity;
}
if (this.cameraMask != null)
{
this.cameraMask.Clear();
}
}
}
yield break;
}
void RenderEye(SteamVR vr, EVREye eye)
{
eyePreRenderCallback?.Invoke(eye);
int i = (int)eye;
SteamVR_Render.eye = eye;
if (cameraMask != null)
{
cameraMask.Set(vr, eye);
}
foreach (var c in cameras)
{
c.transform.localPosition = vr.eyes[i].pos;
c.transform.localRotation = vr.eyes[i].rot;
// Update position to keep from getting culled
cameraMask.transform.position = c.transform.position;
var camera = c.camera;
camera.targetTexture = SteamVR_Camera.GetSceneTexture(camera.allowHDR);
int cullingMask = camera.cullingMask;
if (eye == EVREye.Eye_Left)
{
camera.cullingMask &= ~rightMask;
camera.cullingMask |= leftMask;
}
else
{
camera.cullingMask &= ~leftMask;
camera.cullingMask |= rightMask;
}
camera.Render();
if (SteamVR_Camera.doomp)
{
Debug.Log(Time.frameCount.ToString() + $"/Render{eye}_OnRenderImage_src.png");
SteamVR_Camera.DumpRenderTexture(camera.targetTexture, Application.streamingAssetsPath + $"/Render{eye}_OnRenderImage_src.png");
}
camera.cullingMask = cullingMask;
}
eyePostRenderCallback?.Invoke(eye);
}
public void InitializeSteamVR(bool forceUnityVRToOpenVR = false)
{
if (forceUnityVRToOpenVR)
{
forcingInitialization = true;
if (initializeCoroutine != null)
StopCoroutine(initializeCoroutine);
if (XRSettings.loadedDeviceName == openVRDeviceName)
EnableOpenVR();
else
initializeCoroutine = StartCoroutine(DoInitializeSteamVR(forceUnityVRToOpenVR));
}
else
{
SteamVR.Initialize(false);
}
}
public static void Initialize(bool forceUnityVRMode = false)
{
if (forceUnityVRMode)
{
SteamVR_Behaviour.instance.InitializeSteamVR(true);
return;
}
if (SteamVR._instance == null)
{
SteamVR._instance = SteamVR.CreateInstance();
if (SteamVR._instance == null)
{
SteamVR._enabled = false;
}
}
if (SteamVR._enabled)
{
SteamVR_Behaviour.Initialize(forceUnityVRMode);
}
}
private static void LoadInstance()
{
if (_instance == null)
{
_instance = Resources.Load <SteamVR_Settings>("SteamVR_Settings");
if (_instance == null)
{
_instance = SteamVR_Settings.CreateInstance <SteamVR_Settings>();
#if UNITY_EDITOR
string localFolderPath = SteamVR.GetSteamVRResourcesFolderPath(true);
string assetPath = System.IO.Path.Combine(localFolderPath, "SteamVR_Settings.asset");
UnityEditor.AssetDatabase.CreateAsset(_instance, assetPath);
UnityEditor.AssetDatabase.SaveAssets();
#endif
}
SetDefaultsIfNeeded();
}
}
public static void CopyFiles(bool force = false)
{
bool hasCopied = EditorPrefs.GetBool(steamVRInputExampleJSONCopiedKey, false);
if (hasCopied == false || force == true)
{
string actionsFilePath = SteamVR_Input.GetActionsFilePath();
bool exists = File.Exists(actionsFilePath);
if (exists == false)
{
string steamVRFolder = SteamVR.GetSteamVRFolderPath();
string exampleLocation = Path.Combine(steamVRFolder, exampleJSONFolderParent);
string exampleFolderPath = Path.Combine(exampleLocation, exampleJSONFolderName);
string streamingAssetsPath = SteamVR_Input.GetActionsFileFolder();
string[] files = Directory.GetFiles(exampleFolderPath, "*.json");
foreach (string file in files)
{
string filename = Path.GetFileName(file);
string newPath = Path.Combine(streamingAssetsPath, filename);
try
{
File.Copy(file, newPath, false);
Debug.Log("<b>[SteamVR]</b> Copied example input JSON to path: " + newPath);
}
catch
{
Debug.LogError("<b>[SteamVR]</b> Could not copy file: " + file + " to path: " + newPath);
}
}
EditorPrefs.SetBool(steamVRInputExampleJSONCopiedKey, true);
}
}
}
public void InitializeSteamVR(bool forceUnityVRToOpenVR = false)
{
if (forceUnityVRToOpenVR)
{
SteamVR_Behaviour.forcingInitialization = true;
if (this.initializeCoroutine != null)
{
this.StopCoroutine(this.initializeCoroutine);
}
if (XRSettings.loadedDeviceName == "OpenVR")
{
this.EnableOpenVR();
}
else
{
this.initializeCoroutine = this.StartCoroutine(this.DoInitializeSteamVR(forceUnityVRToOpenVR));
}
}
else
{
SteamVR.Initialize(false);
}
}
private static void SetDefaultsIfNeeded()
{
if (string.IsNullOrEmpty(_instance.editorAppKey))
{
_instance.editorAppKey = SteamVR.GenerateAppKey();
Debug.Log("<b>[SteamVR Setup]</b> Generated you an editor app key of: " + _instance.editorAppKey + ". This lets the editor tell SteamVR what project this is. Has no effect on builds. This can be changed in Assets/SteamVR/Resources/SteamVR_Settings");
#if UNITY_EDITOR
EditorUtility.SetDirty(_instance);
AssetDatabase.SaveAssets();
#endif
}
#if UNITY_EDITOR
if (_instance.previewHandLeft == null)
{
_instance.previewHandLeft = FindDefaultPreviewHand(previewLeftDefaultAssetName);
}
if (_instance.previewHandRight == null)
{
_instance.previewHandRight = FindDefaultPreviewHand(previewRightDefaultAssetName);
}
#endif
}
public static string GenerateAppKey()
{
string arg = SteamVR.GenerateCleanProductName();
return(string.Format("application.generated.unity.{0}.exe", arg));
}
private void EnableOpenVR()
{
XRSettings.enabled = true;
SteamVR.Initialize(false);
SteamVR_Behaviour.forcingInitialization = false;
}
void OnApplicationQuit()
{
isQuitting = true;
SteamVR.SafeDispose();
}
private void OnApplicationQuit()
{
SteamVR_Render.isQuitting = true;
SteamVR.SafeDispose();
}
private void Update()
{
if (!SteamVR.active)
{
return;
}
this.UpdatePoses();
CVRSystem system = OpenVR.System;
if (system != null)
{
VREvent_t vrevent_t = default(VREvent_t);
uint uncbVREvent = (uint)Marshal.SizeOf(typeof(VREvent_t));
int num = 0;
while (num < 64 && system.PollNextEvent(ref vrevent_t, uncbVREvent))
{
EVREventType eventType = (EVREventType)vrevent_t.eventType;
if (eventType <= EVREventType.VREvent_InputFocusReleased)
{
if (eventType != EVREventType.VREvent_InputFocusCaptured)
{
if (eventType != EVREventType.VREvent_InputFocusReleased)
{
goto IL_CA;
}
if (vrevent_t.data.process.pid == 0u)
{
SteamVR_Events.InputFocus.Send(true);
}
}
else if (vrevent_t.data.process.oldPid == 0u)
{
SteamVR_Events.InputFocus.Send(false);
}
}
else if (eventType != EVREventType.VREvent_HideRenderModels)
{
if (eventType != EVREventType.VREvent_ShowRenderModels)
{
goto IL_CA;
}
SteamVR_Events.HideRenderModels.Send(false);
}
else
{
SteamVR_Events.HideRenderModels.Send(true);
}
IL_C4:
num++;
continue;
IL_CA:
SteamVR_Events.System((EVREventType)vrevent_t.eventType).Send(vrevent_t);
goto IL_C4;
}
}
Application.targetFrameRate = -1;
Application.runInBackground = true;
QualitySettings.maxQueuedFrames = -1;
QualitySettings.vSyncCount = 0;
if (SteamVR.settings.lockPhysicsUpdateRateToRenderFrequency && Time.timeScale > 0f)
{
SteamVR instance = SteamVR.instance;
if (instance != null)
{
Time.fixedDeltaTime = Time.timeScale / instance.hmd_DisplayFrequency;
}
}
}
private void OnGUI()
{
if (headerLabelStyle == null)
{
headerLabelStyle = new GUIStyle(EditorStyles.boldLabel);
}
if (multiLineStyle == null)
{
multiLineStyle = new GUIStyle(EditorStyles.wordWrappedLabel);
}
if (smallMultiLineStyle == null)
{
smallMultiLineStyle = new GUIStyle(EditorStyles.wordWrappedLabel);
smallMultiLineStyle.fontSize = EditorStyles.miniLabel.fontSize;
smallMultiLineStyle.fontStyle = FontStyle.Italic;
}
if (folderName == null)
{
folderName = "SteamVR_" + SteamVR.GenerateCleanProductName();
}
SteamVR_Input.InitializeFile();
EditorGUILayout.Space();
EditorGUILayout.LabelField("Partial input bindings", headerLabelStyle);
EditorGUILayout.LabelField(
"When you create a partial bindings folder you can include that anywhere inside your asset package folder and it will automatically be found and imported to the user's project on load.",
multiLineStyle);
EditorGUILayout.LabelField("note: You can rename the folder but do not rename any files inside.",
smallMultiLineStyle);
EditorGUILayout.Space();
EditorGUILayout.Space();
folderName = EditorGUILayout.TextField("Name", folderName);
EditorGUILayout.Space();
version = EditorGUILayout.IntField("Version", version);
EditorGUILayout.LabelField("note: only whole numbers", smallMultiLineStyle);
EditorGUILayout.Space();
overwriteOldActions = EditorGUILayout.Toggle("Overwrite old actions", overwriteOldActions);
EditorGUILayout.LabelField(
"If the person importing your asset package has a previous version of your package this determines whether or not to overwrite actions and bindings that have the same name.",
smallMultiLineStyle);
EditorGUILayout.Space();
removeOldVersionActions =
EditorGUILayout.Toggle("Remove unused actions from old versions", overwriteOldActions);
EditorGUILayout.LabelField(
"If the person importing your asset package has a previous version of your package that has actions that are not used in the new version of your package this determines whether or not to delete those actions.",
smallMultiLineStyle);
EditorGUILayout.Space();
EditorGUILayout.Space();
bool create = GUILayout.Button("Create");
if (create)
{
SteamVR_Input_ActionManifest_Manager.CreatePartial(folderName, version, overwriteOldActions,
removeOldVersionActions);
}
}
/// <summary>
/// Returns an array of positions/rotations that represent the state of each bone in a reference pose.
/// </summary>
/// <param name="referencePose">Which reference pose to return</param>
public void ForceToReferencePose(EVRSkeletalReferencePose referencePose)
{
bool temporarySession = false;
if (Application.isEditor && Application.isPlaying == false)
{
temporarySession = SteamVR.InitializeTemporarySession(true);
Awake();
#if UNITY_EDITOR
//gotta wait a bit for steamvr input to startup //todo: implement steamvr_input.isready
string title = "SteamVR";
string text = "Getting reference pose...";
float msToWait = 3000;
float increment = 100;
for (float timer = 0; timer < msToWait; timer += increment)
{
bool cancel = UnityEditor.EditorUtility.DisplayCancelableProgressBar(title, text, timer / msToWait);
if (cancel)
{
UnityEditor.EditorUtility.ClearProgressBar();
if (temporarySession)
{
SteamVR.ExitTemporarySession();
}
return;
}
System.Threading.Thread.Sleep((int)increment);
}
UnityEditor.EditorUtility.ClearProgressBar();
#endif
skeletonAction.actionSet.Activate();
SteamVR_ActionSet_Manager.UpdateActionStates(true);
skeletonAction.UpdateValueWithoutEvents();
}
if (skeletonAction.active == false)
{
Debug.LogError("<b>[SteamVR Input]</b> Please turn on your " + inputSource.ToString() + " controller and ensure SteamVR is open.");
return;
}
SteamVR_Utils.RigidTransform[] transforms = skeletonAction.GetReferenceTransforms(EVRSkeletalTransformSpace.Parent, referencePose);
if (transforms == null || transforms.Length == 0)
{
Debug.LogError("<b>[SteamVR Input]</b> Unable to get the reference transform for " + inputSource.ToString() + ". Please make sure SteamVR is open and both controllers are connected.");
}
for (int boneIndex = 0; boneIndex < transforms.Length; boneIndex++)
{
bones[boneIndex].localPosition = transforms[boneIndex].pos;
bones[boneIndex].localRotation = transforms[boneIndex].rot;
}
if (temporarySession)
{
SteamVR.ExitTemporarySession();
}
}
public static bool GetBounds(Size size, ref HmdQuad_t pRect)
{
if (size == Size.Calibrated)
{
bool temporarySession = false;
if (Application.isEditor && Application.isPlaying == false)
{
temporarySession = SteamVR.InitializeTemporarySession();
}
var chaperone = OpenVR.Chaperone;
bool success = (chaperone != null) && chaperone.GetPlayAreaRect(ref pRect);
if (!success)
{
Debug.LogWarning(
"<b>[SteamVR]</b> Failed to get Calibrated Play Area bounds! Make sure you have tracking first, and that your space is calibrated.");
}
if (temporarySession)
{
SteamVR.ExitTemporarySession();
}
return(success);
}
else
{
try
{
var str = size.ToString().Substring(1);
var arr = str.Split(new char[] { 'x' }, 2);
// convert to half size in meters (from cm)
var x = float.Parse(arr[0]) / 200;
var z = float.Parse(arr[1]) / 200;
pRect.vCorners0.v0 = x;
pRect.vCorners0.v1 = 0;
pRect.vCorners0.v2 = -z;
pRect.vCorners1.v0 = -x;
pRect.vCorners1.v1 = 0;
pRect.vCorners1.v2 = -z;
pRect.vCorners2.v0 = -x;
pRect.vCorners2.v1 = 0;
pRect.vCorners2.v2 = z;
pRect.vCorners3.v0 = x;
pRect.vCorners3.v1 = 0;
pRect.vCorners3.v2 = z;
return(true);
}
catch
{
}
}
return(false);
}
private static SteamVR CreateInstance()
{
SteamVR.initializedState = SteamVR.InitializedStates.Initializing;
try
{
EVRInitError evrinitError = EVRInitError.None;
OpenVR.GetGenericInterface("IVRCompositor_022", ref evrinitError);
OpenVR.Init(ref evrinitError, EVRApplicationType.VRApplication_Scene, "");
CVRSystem system = OpenVR.System;
string manifestFile = SteamVR.GetManifestFile();
EVRApplicationError evrapplicationError = OpenVR.Applications.AddApplicationManifest(manifestFile, true);
if (evrapplicationError != EVRApplicationError.None)
{
UnityEngine.Debug.LogError("<b>[SteamVR_Standalone]</b> Error adding vr manifest file: " + evrapplicationError.ToString());
}
int id = Process.GetCurrentProcess().Id;
OpenVR.Applications.IdentifyApplication((uint)id, SteamVR_Settings.instance.editorAppKey);
UnityEngine.Debug.Log("Is HMD here? " + OpenVR.IsHmdPresent().ToString());
if (evrinitError != EVRInitError.None)
{
SteamVR.initializedState = SteamVR.InitializedStates.InitializeFailure;
SteamVR.ReportError(evrinitError);
SteamVR.ReportGeneralErrors();
SteamVR_Events.Initializing.Send(false);
return(null);
}
OpenVR.GetGenericInterface("IVROverlay_021", ref evrinitError);
if (evrinitError != EVRInitError.None)
{
SteamVR.initializedState = SteamVR.InitializedStates.InitializeFailure;
SteamVR.ReportError(evrinitError);
SteamVR_Events.Initializing.Send(false);
return(null);
}
OpenVR.GetGenericInterface("IVRInput_007", ref evrinitError);
if (evrinitError != EVRInitError.None)
{
SteamVR.initializedState = SteamVR.InitializedStates.InitializeFailure;
SteamVR.ReportError(evrinitError);
SteamVR_Events.Initializing.Send(false);
return(null);
}
SteamVR.settings = SteamVR_Settings.instance;
if (Application.isEditor)
{
SteamVR.IdentifyEditorApplication(true);
}
SteamVR_Input.IdentifyActionsFile(true);
if (SteamVR_Settings.instance.inputUpdateMode != SteamVR_UpdateModes.Nothing || SteamVR_Settings.instance.poseUpdateMode != SteamVR_UpdateModes.Nothing)
{
SteamVR_Input.Initialize(false);
}
}
catch (Exception arg)
{
UnityEngine.Debug.LogError("<b>[SteamVR_Standalone]</b> " + arg);
SteamVR_Events.Initializing.Send(false);
return(null);
}
SteamVR._enabled = true;
SteamVR.initializedState = SteamVR.InitializedStates.InitializeSuccess;
SteamVR_Events.Initializing.Send(true);
return(new SteamVR());
}
