public static Texture GetPlatformIcon(VRPlatform platform)
{
switch (platform)
{
case VRPlatform.OculusMobile:
case VRPlatform.OculusPC:
return(platformImages[1]);
case VRPlatform.None:
return(platformImages[0]);
case VRPlatform.Daydream:
return(platformImages[4]);
case VRPlatform.SteamVR:
return(platformImages[2]);
case VRPlatform.PlayStationVR:
return(platformImages[3]);
case VRPlatform.WindowsMR:
return(platformImages[5]);
default:
return(null);
}
}
static void SavePlatformSettings(VRPlatform platform)
{
switch (platform)
{
case VRPlatform.OculusMobile:
case VRPlatform.OculusPC:
TBOculusEditorSDKSettings.instance.SaveSettings();
break;
case VRPlatform.SteamVR:
TBSteamVREditorSDKSettings.instance.SaveSettings();
break;
case VRPlatform.Daydream:
TBGoogleEditorSDKSettings.instance.SaveSettings();
break;
#if TB_HAS_UNITY_PS4
case VRPlatform.PlayStationVR:
TBPSVREditorSDKSettings.instance.SaveSettings();
break;
#endif
case VRPlatform.WindowsMR:
TBWindowsMREditorSDKSettings.instance.SaveSettings();
break;
}
}
private static void SetActivePlatform()
{
if (!UnityEngine.XR.XRSettings.enabled)
{
TBLogging.LogMessage("VR is disabled in PlayerSettings (or Unity's XRSettings). Setting VRPlatform to None.");
_activePlatform = VRPlatform.None;
return;
}
switch (UnityEngine.XR.XRSettings.loadedDeviceName)
{
case TBSettings.VRDeviceNames.Oculus:
if (Application.isMobilePlatform)
{
_activePlatform = VRPlatform.OculusMobile;
}
else
{
_activePlatform = VRPlatform.OculusPC;
}
break;
case TBSettings.VRDeviceNames.SteamVR:
#if !TB_STEAM_VR
_activePlatform = VRPlatform.OculusPC; // Allows Oculus Utilities to be used as a fallback if Steam VR plugin is not present.
#else
_activePlatform = VRPlatform.SteamVR;
#endif
break;
case TBSettings.VRDeviceNames.Daydream:
_activePlatform = VRPlatform.Daydream;
break;
case TBSettings.VRDeviceNames.PlayStationVR:
_activePlatform = VRPlatform.PlayStationVR;
break;
case TBSettings.VRDeviceNames.WindowsMR:
_activePlatform = VRPlatform.WindowsMR;
break;
default:
if (string.IsNullOrEmpty(UnityEngine.XR.XRSettings.loadedDeviceName))
{
TBLogging.LogMessage("No VR device is currently loaded in Unity's XRSettings, even though VR was enabled. That may be a sign of an error.");
}
else
{
Debug.LogError("Detected " + UnityEngine.XR.XRSettings.loadedDeviceName);
Debug.LogError("The current HMD / SDK pairing doesn't match any known TButt preset! TCore initialization failed.");
}
_activePlatform = VRPlatform.None;
UnityEngine.XR.XRSettings.enabled = false;
return;
}
TBLogging.LogMessage("TBCore's VRPlatform is now " + _activePlatform + ". Configured for " + UnityEngine.XR.XRDevice.model + " running through " + UnityEngine.XR.XRSettings.loadedDeviceName + " SDK");
}
private static void LoadSettings(VRPlatform platform)
{
if (_loadedSettings)
{
return;
}
// Get control and camera settings.
_controlSettings = TBDataManager.DeserializeFromFile <TBControlSettings>(settingsFolder + controlSettingsFileName, TBDataManager.PathType.ResourcesFolder);
if (!_controlSettings.supports3DOFControllers && !_controlSettings.supportsClickRemote && !_controlSettings.supportsGamepad && !_controlSettings.supportsHandControllers)
{
UnityEngine.Debug.LogWarning("No controller types are enabled in TBInput's settings!");
}
PrintControlSettings();
_cameraSettings = TBDataManager.DeserializeFromFile <TBCameraSettings>(settingsFolder + cameraSettingsFilename, TBDataManager.PathType.ResourcesFolder);
// Setup platform settings subclass.
switch (platform)
{
case VRPlatform.OculusPC:
case VRPlatform.OculusMobile:
_settingsBase = TBCore.instance.gameObject.AddComponent <TBOculusSettings>();
break;
#if TB_HAS_UNITY_PS4
case VRPlatform.PlayStationVR:
_settingsBase = TBCore.instance.gameObject.AddComponent <TBSettingsPSVR>();
break;
#endif
case VRPlatform.WindowsMR:
_settingsBase = TBCore.instance.gameObject.AddComponent <TBWindowsMRSettings>();
break;
case VRPlatform.SteamVR:
_settingsBase = TBCore.instance.gameObject.AddComponent <TBSteamVRSettings>();
break;
case VRPlatform.Daydream:
_settingsBase = TBCore.instance.gameObject.AddComponent <TBGoogleSettings>();
break;
default:
_settingsBase = TBCore.instance.gameObject.AddComponent <TBSettingsBase>();
break;
}
_settingsBase.Initialize();
// Apply quality settings overrides if needed.
if (_settingsBase.GetDisplaySettings().qualitySettings.enableQualitySettingsOverride)
{
ApplyQualitySettingsOverrides(_settingsBase.GetDisplaySettings().qualitySettings);
}
// Set timestep.
SetTimestep();
_loadedSettings = true;
}
static void CheckPlatformMenu()
{
VRPlatform curPlatform = GetPlatformPrefs();
Menu.SetChecked(CardboardMenu, curPlatform == VRPlatform.Cardboard);
Menu.SetChecked(DaydreamMenu, curPlatform == VRPlatform.Daydream);
Menu.SetChecked(GearVRPMenu, curPlatform == VRPlatform.GearVR);
Menu.SetChecked(LuancherMenu, curPlatform == VRPlatform.Launcher);
}
/// <summary>
/// Override function to force TBCore to initialize for a specific platform.
/// Only necessary for devices that can start without a headset active.
/// </summary>
/// <param name="platform"></param>
public static void Initialize(VRPlatform platform)
{
if (!_loadedSettings)
{
LoadSettings(platform);
}
else
{
TBLogging.LogMessage("TBSettings.Initialize() was called, but settings were already initialized.");
}
}
public static void ShowControllerMatrixHeader(bool show, VRPlatform platform, GUIStyle color)
{
if (show)
{
EditorGUILayout.BeginVertical(color, new GUILayoutOption[1] {
GUILayout.Width(controllerColumnWidth)
});
GUILayout.Label(TBEditorStyles.GetPlatformIcon(platform), TBEditorStyles.h1centered);
EditorGUILayout.EndVertical();
}
}
private void SetupNativeCamera(VRPlatform platform)
{
_centerEyeTransform = new GameObject().transform;
_centerEyeTransform.MakeZeroedChildOf(_trackingVolume);
_centerEyeTransform.gameObject.name = "Standard VR Camera";
_centerEyeTransform.gameObject.tag = "MainCamera";
_primaryCamera = _centerEyeTransform.gameObject.AddComponent <Camera>();
switch (platform)
{
case VRPlatform.OculusMobile:
case VRPlatform.OculusPC:
_cameraMode = CameraMode.Single;
_baseCamera = _primaryCamera.gameObject.AddComponent <TBCameraOculus>();
break;
case VRPlatform.SteamVR:
_cameraMode = CameraMode.Single;
_baseCamera = _primaryCamera.gameObject.AddComponent <TBSteamVRCamera>();
break;
#if TB_HAS_UNITY_PS4
case VRPlatform.PlayStationVR:
_cameraMode = CameraMode.Single;
_baseCamera = _primaryCamera.gameObject.AddComponent <TBCameraPSVR>();
break;
#endif
case VRPlatform.Daydream:
_cameraMode = CameraMode.Single;
_baseCamera = _primaryCamera.gameObject.AddComponent <TBCameraGoogle>();
break;
default:
_cameraMode = CameraMode.Single;
_baseCamera = _primaryCamera.gameObject.AddComponent <TBCameraBase>();
break;
}
_baseCamera.Initialize();
if (TBTracking.OnNodeConnected != null)
{
TBTracking.OnNodeConnected(UnityEngine.XR.XRNode.CenterEye, _centerEyeTransform);
TBTracking.OnNodeConnected(UnityEngine.XR.XRNode.Head, _centerEyeTransform);
TBTracking.OnNodeConnected(UnityEngine.XR.XRNode.TrackingReference, _trackingVolume);
}
_trackingVolume.localScale = Vector3.one;
}
private void SetupCameraForPlatform(VRPlatform platform)
{
switch (platform)
{
default:
SetupNativeCamera(platform);
DestroyTempCamera();
break;
case VRPlatform.None:
_primaryCamera = GetComponent <Camera>();
_centerEyeTransform = transform;
break;
}
_audioListenerTransform = new GameObject("AudioListener").transform;
_audioListener = _audioListenerTransform.gameObject.AddComponent <AudioListener>();
_audioListenerTransform.gameObject.AddComponent <TBAudioListener>();
}
private void SetupNativeCamera(VRPlatform platform)
{
_primaryCamera = _centerEyeTransform.gameObject.AddComponent <Camera>();
switch (platform)
{
case VRPlatform.OculusMobile:
case VRPlatform.OculusPC:
_cameraMode = CameraMode.Single;
_baseCamera = _primaryCamera.gameObject.AddComponent <TBCameraOculus>();
break;
case VRPlatform.SteamVR:
_cameraMode = CameraMode.Single;
_baseCamera = _primaryCamera.gameObject.AddComponent <TBSteamVRCamera>();
break;
#if TB_HAS_UNITY_PS4
case VRPlatform.PlayStationVR:
_cameraMode = CameraMode.Single;
_baseCamera = _primaryCamera.gameObject.AddComponent <TBCameraPSVR>();
break;
#endif
case VRPlatform.Daydream:
_cameraMode = CameraMode.Single;
_baseCamera = _primaryCamera.gameObject.AddComponent <TBCameraGoogle>();
break;
default:
_cameraMode = CameraMode.Single;
_baseCamera = _primaryCamera.gameObject.AddComponent <TBCameraBase>();
break;
}
_baseCamera.Initialize();
_trackingVolume.localScale = Vector3.one;
}
// FixedUpdate is called before any Update
public void Update()
{
if (CheckForSpatialInputActive() == false)
{
return;
}
Vector3 rootPos = spatialCamRig.transform.position;
SpatialDevice[] hands = { Left, Right };
for (int i = 0; i < 2; ++i)
{
SpatialDevice h = hands[i];
h.CursorActive = VRPlatform.IsSpatialDeviceTracked(i);
if (h.CursorActive)
{
h.Hand.Show();
h.Cursor.Show();
Vector3 handPos = VRPlatform.GetLocalControllerPosition(i);
Quaternion handRot = VRPlatform.GetLocalControllerRotation(i);
h.AbsoluteHandFrame = new Frame3f(rootPos + handPos, handRot);
float fPositionT = 0.2f;
float fRotationT = 0.2f;
//float fPositionT = 1.0f;
//float fRotationT = 1.0f;
if (h.SmoothedHandFrame.Origin != Vector3f.Zero)
{
Vector3 new_origin =
Vector3.Lerp(h.SmoothedHandFrame.Origin, h.AbsoluteHandFrame.Origin, fPositionT);
Quaternion new_rotation =
Quaternion.Slerp(h.SmoothedHandFrame.Rotation, h.AbsoluteHandFrame.Rotation, fRotationT);
h.SmoothedHandFrame = new Frame3f(new_origin, new_rotation);
}
else
{
h.SmoothedHandFrame = h.AbsoluteHandFrame;
}
h.Hand.transform.position = h.SmoothedHandFrame.Origin;
h.Hand.transform.rotation = h.SmoothedHandFrame.Rotation * (Quaternionf)handGeomRotation;
h.CursorRay = new Ray(h.SmoothedHandFrame.Origin,
(h.SmoothedHandFrame.Rotation * Vector3.forward).Normalized);
if (Mathf.Abs(h.CursorRay.direction.sqrMagnitude - 1.0f) > 0.001f)
{
DebugUtil.Log(2, "SpatialInputController.Update - invlaid cursor ray! rotation was {0}", h.SmoothedHandFrame.Rotation);
h.CursorRay = new Ray(h.SmoothedHandFrame.Origin, Vector3.up);
}
// raycast into scene to see if we hit object, UI, bounds, etc.
bool bHit = false;
if (context != null)
{
// want to hit-test active gizmo first, because that has hit-priority
if (context.TransformManager.HaveActiveGizmo)
{
UIRayHit uiHit = null;
if (context.TransformManager.ActiveGizmo.FindRayIntersection(h.CursorRay, out uiHit))
{
h.RayHitPos = uiHit.hitPos;
bHit = true;
}
}
// next we tested scene
if (bHit == false)
{
AnyRayHit hit = null;
if (context.FindAnyRayIntersection(h.CursorRay, out hit))
{
h.RayHitPos = hit.hitPos;
bHit = true;
}
}
// finally test worldbounds
if (bHit == false)
{
GameObjectRayHit ghit = null;
if (context.GetScene().FindWorldBoundsHit(h.CursorRay, out ghit))
{
h.RayHitPos = ghit.hitPos;
}
}
}
// if not, plane cursor on view-perp plane centered at last hit pos,
// otherwise it will be stuck/disappear
if (bHit == false)
{
Frame3f f = new Frame3f(h.RayHitPos, camera.transform.forward);
h.RayHitPos = f.RayPlaneIntersection(h.CursorRay.origin, h.CursorRay.direction, 2);
}
h.Cursor.transform.position = h.RayHitPos;
//if (scene.InCapture)
// MaterialUtil.SetMaterial(h.Cursor, h.CursorCapturingMaterial);
//else
if (bHit)
{
MaterialUtil.SetMaterial(h.Cursor, h.CursorHitMaterial);
}
else
{
MaterialUtil.SetMaterial(h.Cursor, h.CursorDefaultMaterial);
}
// maintain a consistent visual size for 3D cursor sphere
float fScaling = VRUtil.GetVRRadiusForVisualAngle(h.RayHitPos, camera.transform.position, CursorVisualAngleInDegrees);
h.Cursor.transform.localScale = fScaling * Vector3.one;
// orient cursor so it is tilted like a 2D cursor, but per-hand
Vector3 cursor_right = Vector3.Cross(camera.transform.up, h.CursorRay.direction);
Vector3 cursor_fw = Vector3.Cross(cursor_right, camera.transform.up);
float rotSign = (h == Right) ? 1.0f : -1.0f;
Vector3 pointDir = (camera.transform.up + cursor_fw - 0.5f * rotSign * cursor_right).normalized;
h.Cursor.transform.localRotation = Quaternion.FromToRotation(Vector3.up, pointDir);
// update laser line
if (h.Laser != null)
{
float hDist = (h.RayHitPos - h.CursorRay.origin).magnitude;
Vector3 p0 = h.RayHitPos - 0.9f * hDist * h.CursorRay.direction;
Vector3 p1 = h.RayHitPos + 100.0f * h.CursorRay.direction;
float r0 = VRUtil.GetVRRadiusForVisualAngle(p0, camera.transform.position, 0.5f);
h.LaserRen.SetPosition(0, p0);
h.LaserRen.SetPosition(1, p1);
h.LaserRen.startWidth = h.LaserRen.endWidth = r0;
}
// udpate cursor
Mesh useMesh = context.ToolManager.HasActiveTool(i) ? activeToolCursorMesh : standardCursorMesh;
if (h.Cursor.GetSharedMesh() != useMesh)
{
h.Cursor.SetSharedMesh(useMesh);
}
}
else
{
h.Hand.Hide();
h.Cursor.Hide();
}
}
}
static void SavePlatformPrefs(VRPlatform platform)
{
AssetDatabase.Refresh();
}
/// <summary>
/// Applies settings and adds required components for input to be detected based on the active platform.
/// </summary>
public static void Initialize(VRPlatform platform)
{
TBCore.OnUpdate += TBInput.Update;
#if UNITY_EDITOR
_activeControlType = TBSettings.GetControlSettings().defaultEditorControlType;
#endif
_hasActiveSDK = true;
switch (platform)
{
case VRPlatform.OculusPC:
case VRPlatform.OculusMobile:
TBInputOculus.instance.Initialize();
TBCore.OnFixedUpdate += TBInputOculus.instance.FixedUpdate;
TBCore.OnUpdate += TBInputOculus.instance.Update;
_activeSDK = TBInputOculus.instance;
break;
case VRPlatform.SteamVR:
TBInputSteamVR.instance.Initialize();
TBCore.OnFixedUpdate += TBInputSteamVR.instance.FixedUpdate;
TBCore.OnUpdate += TBInputSteamVR.instance.Update;
_activeSDK = TBInputSteamVR.instance;
break;
case VRPlatform.Daydream:
TBInputGoogle.instance.Initialize();
TBCore.OnFixedUpdate += TBInputGoogle.instance.FixedUpdate;
TBCore.OnUpdate += TBInputGoogle.instance.Update;
_activeSDK = TBInputGoogle.instance;
break;
case VRPlatform.PlayStationVR:
#if TB_HAS_UNITY_PS4
TBPSVRInput.instance.Initialize();
TBCore.OnFixedUpdate += TBPSVRInput.instance.FixedUpdate;
TBCore.OnUpdate += TBPSVRInput.instance.Update;
_activeSDK = TBPSVRInput.instance;
#else
UnityEngine.Debug.LogError("TBInput attempted to initialize for PSVR, but the PSVR module is not available. Is the module installed and set up with #TB_HAS_UNITY_PS4?");
#endif
break;
case VRPlatform.WindowsMR:
TBWindowsMRInput.instance.Initialize();
TBCore.OnFixedUpdate += TBWindowsMRInput.instance.FixedUpdate;
TBCore.OnUpdate += TBWindowsMRInput.instance.Update;
_activeSDK = TBWindowsMRInput.instance;
break;
default:
_hasActiveSDK = false;
UnityEngine.Debug.LogError("Attempted to initialize TBInput without an active SDK in TBCore. This shouldn't happen if TBCore exists in your scene.");
break;
}
TBLogging.LogMessage("Active Control Type: " + _activeControlType);
if (_activeControlType == ControlType.None)
{
TBLogging.LogMessage("No active control type is assigned to TBInput. Input for type 'active' will be ignored until a control type is assigned.");
}
}
