public static void Deregister(NVRInteractable interactable)
{
NVRPlayer.DeregisterInteractable(interactable);
ColliderMapping = ColliderMapping.Where(mapping => mapping.Value != interactable).ToDictionary(mapping => mapping.Key, mapping => mapping.Value);
NVRInteractableMapping.Remove(interactable);
}
protected override void Start()
{
base.Start();
if (Initialized == false)
{
StartCoroutine(DelayedCameraInit());
Player = this.GetComponent <NVRPlayer>();
Cursors = new RectTransform[Player.Hands.Length];
Lasers = new LineRenderer[Cursors.Length];
for (int index = 0; index < Cursors.Length; index++)
{
GameObject cursor = new GameObject("Cursor for " + Player.Hands[index].gameObject.name);
cursor.transform.parent = this.transform;
cursor.transform.localPosition = Vector3.zero;
cursor.transform.localRotation = Quaternion.identity;
Canvas canvas = cursor.AddComponent <Canvas>();
cursor.AddComponent <CanvasRenderer>();
cursor.AddComponent <CanvasScaler>();
cursor.AddComponent <NVRUIIgnoreRaycast>();
cursor.AddComponent <GraphicRaycaster>();
canvas.renderMode = RenderMode.WorldSpace;
canvas.sortingOrder = 1000; //set to be on top of everything
Image image = cursor.AddComponent <Image>();
image.sprite = CursorSprite;
image.material = CursorMaterial;
if (LaserEnabled == true)
{
Lasers[index] = cursor.AddComponent <LineRenderer>();
Lasers[index].material = new Material(Shader.Find("Standard"));
Lasers[index].material.color = LaserColor;
NVRHelpers.LineRendererSetColor(Lasers[index], LaserColor, LaserColor);
NVRHelpers.LineRendererSetWidth(Lasers[index], LaserStartWidth, LaserEndWidth);
Lasers[index].useWorldSpace = true;
Lasers[index].enabled = false;
}
if (CursorSprite == null)
{
Debug.LogError("Set CursorSprite on " + this.gameObject.name + " to the sprite you want to use as your cursor.", this.gameObject);
}
Cursors[index] = cursor.GetComponent <RectTransform>();
}
CurrentPoint = new GameObject[Cursors.Length];
CurrentPressed = new GameObject[Cursors.Length];
CurrentDragging = new GameObject[Cursors.Length];
PointEvents = new PointerEventData[Cursors.Length];
Initialized = true;
}
}
public override void Initialize(NVRPlayer player)
{
Player = player;
Player.gameObject.SetActive(false);
SteamVR_ControllerManager controllerManager = Player.gameObject.AddComponent <SteamVR_ControllerManager>();
controllerManager.left = Player.LeftHand.gameObject;
controllerManager.right = Player.RightHand.gameObject;
//controllerManager.objects = new GameObject[2] { Player.LeftHand.gameObject, Player.RightHand.gameObject };
Player.gameObject.AddComponent <SteamVR_PlayArea>();
for (int index = 0; index < Player.Hands.Length; index++)
{
Player.Hands[index].gameObject.AddComponent <SteamVR_TrackedObject>();
}
SteamVR_Camera steamVrCamera = Player.Head.gameObject.AddComponent <SteamVR_Camera>();
SteamVR_Ears steamVrEars = Player.Head.gameObject.AddComponent <SteamVR_Ears>();
NVRHelpers.SetField(steamVrCamera, "_head", Player.Head.transform, false);
NVRHelpers.SetField(steamVrCamera, "_ears", Player.Head.transform, false);
Player.Head.gameObject.AddComponent <SteamVR_TrackedObject>();
Player.gameObject.SetActive(true);
}
public override void Initialize(NVRPlayer player)
{
Player = player;
Player.gameObject.SetActive(false);
SteamVR_ControllerManager controllerManager = Player.gameObject.AddComponent <SteamVR_ControllerManager>();
controllerManager.left = Player.LeftHand.gameObject;
controllerManager.right = Player.RightHand.gameObject;
//Player.gameObject.AddComponent<SteamVR_PlayArea>();
for (int index = 0; index < Player.Hands.Length; index++)
{
Player.Hands[index].gameObject.AddComponent <SteamVR_TrackedObject>();
}
SteamVR_Camera steamVrCamera = Player.Head.gameObject.AddComponent <SteamVR_Camera>();
Player.Head.gameObject.AddComponent <SteamVR_Ears>();
NVRHelpers.SetField(steamVrCamera, "_head", Player.Head.transform, false);
NVRHelpers.SetField(steamVrCamera, "_ears", Player.Head.transform, false);
Player.Head.gameObject.AddComponent <SteamVR_TrackedObject>();
Player.gameObject.SetActive(true);
SteamVR_Render[] steamvr_objects = GameObject.FindObjectsOfType <SteamVR_Render>();
for (int objectIndex = 0; objectIndex < steamvr_objects.Length; objectIndex++)
{
steamvr_objects[objectIndex].lockPhysicsUpdateRateToRenderFrequency = false; //this generally seems to break things :) Just make sure your Time -> Physics Timestep is set to 0.011
}
}
public override void Initialize(NVRPlayer player)
{
Player = player;
Player.gameObject.SetActive(false);
if (!Application.isEditor)
{
#if UNITY_WSA
#if UNITY_2017_2_OR_NEWER
if (!UnityEngine.XR.WSA.HolographicSettings.IsDisplayOpaque)
#endif
{
CurrentDisplayType = DisplayType.Transparent;
ApplySettingsForTransparentDisplay(Player.Head.GetComponent <Camera>());
if (OnDisplayDetected != null)
{
OnDisplayDetected(DisplayType.Transparent);
}
return;
}
#endif
}
CurrentDisplayType = DisplayType.Opaque;
ApplySettingsForOpaqueDisplay(Player.Head.GetComponent <Camera>());
if (OnDisplayDetected != null)
{
OnDisplayDetected(DisplayType.Opaque);
}
Player.gameObject.SetActive(true);
}
public override void PreInitialize(NVRPlayer player)
{
IsLeft = Hand == Handedness.Left;
IsRight = Hand == Handedness.Right;
Player = NVRPlayer.Instance;
CurrentInteractionStyle = InterationStyle.Hold;
CurrentlyHoveringOver = new Dictionary<NVRInteractable, Dictionary<Collider, float>>();
LastPositions = new Vector3[EstimationSamples];
LastRotations = new Quaternion[EstimationSamples];
LastDeltas = new float[EstimationSamples];
EstimationSampleIndex = 0;
VisibilityLocked = false;
Inputs = new Dictionary<NVRButtons, NVRButtonInputs>(new NVRButtonsComparer());
for (int buttonIndex = 0; buttonIndex < NVRButtonsHelper.Array.Length; buttonIndex++)
{
if (Inputs.ContainsKey(NVRButtonsHelper.Array[buttonIndex]) == false)
{
Inputs.Add(NVRButtonsHelper.Array[buttonIndex], new NVRButtonInputs());
}
}
var virtualInputDevice = this.gameObject.AddComponent<NVRVirtualInputDevice> ();
virtualInputDevice.radius = radius;
InputDevice = virtualInputDevice;
InputDevice.Initialize (this);
InitializeRenderModel();
}
private void OnDrawGizmos()
{
NVRPlayer player = (NVRPlayer)target;
Vector3 centerPoint = player.transform.position;
centerPoint.y += player.transform.localScale.y / 2;
Handles.CubeCap(5, centerPoint, player.transform.rotation, player.transform.localScale.x);
//Handles.DrawWireCube(centerPoint, player.transform.localScale);
}
// Use this for initialization
void Start()
{
animator = GetComponent <Animator>();
nvrPlayer = GetComponentInParent <NewtonVR.NVRPlayer>();
if (nvrPlayer != null)
{
nvrHand = hand == Hand.LeftHand ? nvrPlayer.LeftHand : nvrPlayer.RightHand;
}
}
private void Awake()
{
Instance = this;
NVRInteractables.Initialize();
if (Head == null)
this.GetComponentInChildren<NVRHead>();
if (Hands == null || Hands.Length == 0)
this.GetComponentsInChildren<NVRHand>();
ColliderToHandMapping = new Dictionary<Collider, NVRHand>();
}
public static void Deregister(NVRInteractable interactable)
{
if (Initialized == false)
{
Debug.LogError("[NewtonVR] Error: NVRInteractables.Register called before initialization.");
}
NVRPlayer.DeregisterInteractable(interactable);
ColliderMapping = ColliderMapping.Where(mapping => mapping.Value != interactable).ToDictionary(mapping => mapping.Key, mapping => mapping.Value);
NVRInteractableMapping.Remove(interactable);
}
private void Start()
{
player = GetComponentInParent <NVRPlayer>();
if (player != null)
{
Vector3 scale = player.PlayspaceSize / 2;
scale.y = 1;
//Render Playspace
PlaySpaceDisplay.gameObject.transform.localScale = scale;
}
else
{
Debug.Log("NVR Player is Null");
}
}
private void Awake()
{
Instance = this;
NVRInteractables.Initialize();
if (Head == null)
{
this.GetComponentInChildren <NVRHead>();
}
if (Hands == null || Hands.Length == 0)
{
this.GetComponentsInChildren <NVRHand>();
}
ColliderToHandMapping = new Dictionary <Collider, NVRHand>();
}
public override void Initialize(NVRPlayer player)
{
Player = player;
//Player.gameObject.SetActive(false);
//OVRManager manager = Player.gameObject.AddComponent<OVRManager>();
//manager.trackingOriginType = OVRManager.TrackingOrigin.FloorLevel;
//OVRCameraRig rig = Player.gameObject.AddComponent<OVRCameraRig>();
//NVRHelpers.SetProperty(rig, "trackingSpace", Player.transform, true);
//NVRHelpers.SetProperty(rig, "leftHandAnchor", Player.LeftHand.transform, true);
//NVRHelpers.SetProperty(rig, "rightHandAnchor", Player.RightHand.transform, true);
//NVRHelpers.SetProperty(rig, "centerEyeAnchor", Player.Head.transform, true);
//Player.gameObject.SetActive(true);
}
private void Awake()
{
Instance = this;
NVRInteractables.Initialize();
if (Head == null)
{
Head = this.GetComponentInChildren <NVRHead>();
}
if (LeftHand == null || RightHand == null)
{
Debug.LogError("[FATAL ERROR] Please set the left and right hand to a nvrhands.");
}
if (Hands == null || Hands.Length == 0)
{
Hands = new NVRHand[] { LeftHand, RightHand };
}
ColliderToHandMapping = new Dictionary <Collider, NVRHand>();
}
private void Awake()
{
Instance = this;
NVRInteractables.Initialize();
if (Head == null)
{
Head = this.GetComponentInChildren<NVRHead>();
}
if (LeftHand == null || RightHand == null)
{
Debug.LogError("[FATAL ERROR] Please set the left and right hand to a nvrhands.");
}
if (Hands == null || Hands.Length == 0)
{
Hands = new NVRHand[] { LeftHand, RightHand };
}
ColliderToHandMapping = new Dictionary<Collider, NVRHand>();
}
public void OnEnable()
{
NVRTeleporter teleporter = (NVRTeleporter)target;
limitToHorizontalProp = serializedObject.FindProperty("LimitToHorizontal");
limitSensitivityProp = serializedObject.FindProperty("LimitSensitivity");
limitToHorizontal = limitToHorizontalProp.boolValue;
useTunnellingProp = serializedObject.FindProperty("TunnelTeleport");
useTunnelling = useTunnellingProp.boolValue;
tunnelOverTimeProp = serializedObject.FindProperty("TunnelOverTime");
vignettePowerProp = serializedObject.FindProperty("VignettePower");
vignetteEaseInTimeProp = serializedObject.FindProperty("VignetteEaseInTime");
vignetteEaseOutTimeProp = serializedObject.FindProperty("VignetteEaseOutTime");
teleportSurfaceMask = serializedObject.FindProperty("TeleportSurfaceMask");
teleportBlockMask = serializedObject.FindProperty("TeleportBlockMask");
arcRendererTemplateProp = serializedObject.FindProperty("ArcRendererDisplay");
playSpaceRendererTemplateProp = serializedObject.FindProperty("PlaySpaceDisplay");
invalidRendererTemplateProp = serializedObject.FindProperty("InvalidPointDisplay");
teleportTargetTemplateProp = serializedObject.FindProperty("TargetDisplay");
arcStrengthProp = serializedObject.FindProperty("ArcStrength");
arcLengthProp = serializedObject.FindProperty("ArcMaxLength");
sampleFrequencyProp = serializedObject.FindProperty("SampleFrequency");
NVRPlayer player = teleporter.gameObject.GetComponentInParent <NVRPlayer>();
if (player != null)
{
_hands = new GameObject[2];
_hands[0] = player.LeftHand.gameObject;
_hands[1] = player.RightHand.gameObject;
}
}
public override void OnInspectorGUI()
{
NVRPlayer player = (NVRPlayer)target;
if (PlayerPrefs.HasKey(CheckForUpdatesKey) == false || PlayerPrefs.GetInt(CheckForUpdatesKey) != System.Convert.ToInt32(player.NotifyOnVersionUpdate))
{
PlayerPrefs.SetInt("NewtonVRCheckForUpdates", System.Convert.ToInt32(player.NotifyOnVersionUpdate));
}
if (hasReloaded == false)
{
DidReloadScripts();
}
if (waitingForReload)
{
HasWaitedLongEnough();
}
player.OculusSDKEnabled = hasOculusSDKDefine;
player.SteamVREnabled = hasSteamVRDefine;
bool installSteamVR = false;
bool installOculusSDK = false;
bool enableSteamVR = player.SteamVREnabled;
bool enableOculusSDK = player.OculusSDKEnabled;
EditorGUILayout.BeginHorizontal();
if (hasSteamVR == false)
{
using (new EditorGUI.DisabledScope(hasSteamVR == false))
{
EditorGUILayout.Toggle("Enable SteamVR", player.SteamVREnabled);
}
installSteamVR = GUILayout.Button("Install SteamVR");
}
else
{
enableSteamVR = EditorGUILayout.Toggle("Enable SteamVR", player.SteamVREnabled);
}
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
if (hasOculusSDK == false)
{
using (new EditorGUI.DisabledScope(hasOculusSDK == false))
{
EditorGUILayout.Toggle("Enable Oculus SDK", player.OculusSDKEnabled);
}
installOculusSDK = GUILayout.Button("Install Oculus SDK");
}
else
{
enableOculusSDK = EditorGUILayout.Toggle("Enable Oculus SDK", player.OculusSDKEnabled);
}
EditorGUILayout.EndHorizontal();
GUILayout.Space(10);
GUILayout.Label("Model override for all SDKs");
bool modelOverrideAll = EditorGUILayout.Toggle("Override hand models for all SDKs", player.OverrideAll);
EditorGUILayout.BeginFadeGroup(1);
using (new EditorGUI.DisabledScope(modelOverrideAll == false))
{
player.OverrideAllLeftHand = (GameObject)EditorGUILayout.ObjectField("Left Hand", player.OverrideAllLeftHand, typeof(GameObject), false);
GUILayout.BeginHorizontal();
GUILayout.Space(20);
player.OverrideAllLeftHandPhysicalColliders = (GameObject)EditorGUILayout.ObjectField("Left Hand Physical Colliders", player.OverrideAllLeftHandPhysicalColliders, typeof(GameObject), false);
GUILayout.EndHorizontal();
player.OverrideAllRightHand = (GameObject)EditorGUILayout.ObjectField("Right Hand", player.OverrideAllRightHand, typeof(GameObject), false);
GUILayout.BeginHorizontal();
GUILayout.Space(20);
player.OverrideAllRightHandPhysicalColliders = (GameObject)EditorGUILayout.ObjectField("Right Hand Physical Colliders", player.OverrideAllRightHandPhysicalColliders, typeof(GameObject), false);
GUILayout.EndHorizontal();
}
EditorGUILayout.EndFadeGroup();
if (modelOverrideAll == true)
{
player.OverrideOculus = false;
player.OverrideSteamVR = false;
}
if (player.OverrideAll != modelOverrideAll)
{
EditorUtility.SetDirty(target);
player.OverrideAll = modelOverrideAll;
}
GUILayout.Space(10);
if (player.OculusSDKEnabled == true)
{
GUILayout.Label("Model override for Oculus SDK");
using (new EditorGUI.DisabledScope(hasOculusSDK == false))
{
bool modelOverrideOculus = EditorGUILayout.Toggle("Override hand models for Oculus SDK", player.OverrideOculus);
EditorGUILayout.BeginFadeGroup(Convert.ToSingle(modelOverrideOculus));
using (new EditorGUI.DisabledScope(modelOverrideOculus == false))
{
player.OverrideOculusLeftHand = (GameObject)EditorGUILayout.ObjectField("Left Hand", player.OverrideOculusLeftHand, typeof(GameObject), false);
GUILayout.BeginHorizontal();
GUILayout.Space(20);
player.OverrideOculusLeftHandPhysicalColliders = (GameObject)EditorGUILayout.ObjectField("Left Hand Physical Colliders", player.OverrideOculusLeftHandPhysicalColliders, typeof(GameObject), false);
GUILayout.EndHorizontal();
player.OverrideOculusRightHand = (GameObject)EditorGUILayout.ObjectField("Right Hand", player.OverrideOculusRightHand, typeof(GameObject), false);
GUILayout.BeginHorizontal();
GUILayout.Space(20);
player.OverrideOculusRightHandPhysicalColliders = (GameObject)EditorGUILayout.ObjectField("Right Hand Physical Colliders", player.OverrideOculusRightHandPhysicalColliders, typeof(GameObject), false);
GUILayout.EndHorizontal();
}
EditorGUILayout.EndFadeGroup();
if (modelOverrideOculus == true)
{
player.OverrideAll = false;
}
if (player.OverrideOculus != modelOverrideOculus)
{
EditorUtility.SetDirty(target);
player.OverrideOculus = modelOverrideOculus;
}
}
}
if (player.SteamVREnabled == true)
{
GUILayout.Label("Model override for SteamVR");
using (new EditorGUI.DisabledScope(hasSteamVR == false))
{
bool modelOverrideSteamVR = EditorGUILayout.Toggle("Override hand models for SteamVR", player.OverrideSteamVR);
EditorGUILayout.BeginFadeGroup(Convert.ToSingle(modelOverrideSteamVR));
using (new EditorGUI.DisabledScope(modelOverrideSteamVR == false))
{
player.OverrideSteamVRLeftHand = (GameObject)EditorGUILayout.ObjectField("Left Hand", player.OverrideSteamVRLeftHand, typeof(GameObject), false);
GUILayout.BeginHorizontal();
GUILayout.Space(20);
player.OverrideSteamVRLeftHandPhysicalColliders = (GameObject)EditorGUILayout.ObjectField("Left Hand Physical Colliders", player.OverrideSteamVRLeftHandPhysicalColliders, typeof(GameObject), false);
GUILayout.EndHorizontal();
player.OverrideSteamVRRightHand = (GameObject)EditorGUILayout.ObjectField("Right Hand", player.OverrideSteamVRRightHand, typeof(GameObject), false);
GUILayout.BeginHorizontal();
GUILayout.Space(20);
player.OverrideSteamVRRightHandPhysicalColliders = (GameObject)EditorGUILayout.ObjectField("Right Hand Physical Colliders", player.OverrideSteamVRRightHandPhysicalColliders, typeof(GameObject), false);
GUILayout.EndHorizontal();
}
EditorGUILayout.EndFadeGroup();
if (modelOverrideSteamVR == true)
{
player.OverrideAll = false;
}
if (player.OverrideSteamVR != modelOverrideSteamVR)
{
EditorUtility.SetDirty(target);
player.OverrideSteamVR = modelOverrideSteamVR;
}
}
GUILayout.Space(10);
}
GUILayout.Space(10);
if (enableSteamVR == false && player.SteamVREnabled == true)
{
RemoveDefine(SteamVRDefine);
}
else if (enableSteamVR == true && player.SteamVREnabled == false)
{
AddDefine(SteamVRDefine);
}
if (enableOculusSDK == false && player.OculusSDKEnabled == true)
{
RemoveDefine(OculusDefine);
}
else if (enableOculusSDK == true && player.OculusSDKEnabled == false)
{
AddDefine(OculusDefine);
}
if (installOculusSDK == true)
{
Application.OpenURL("https://developer3.oculus.com/downloads/game-engines/1.10.0/Oculus_Utilities_for_Unity_5/");
}
if (installSteamVR == true)
{
Application.OpenURL("com.unity3d.kharma:content/32647");
}
DrawDefaultInspector();
if (waitingForReload == true || string.IsNullOrEmpty(progressBarMessage) == false)
{
DisplayProgressBar();
}
if (GUI.changed)
{
if (Application.isPlaying == false)
{
EditorUtility.SetDirty(target);
EditorSceneManager.MarkSceneDirty(SceneManager.GetActiveScene());
}
}
}
public override void Initialize(NVRPlayer player)
{
PrintNotEnabledError();
}
protected override void Start()
{
base.Start();
if (Initialized == false)
{
Player = this.GetComponent <NVRPlayer>();
ControllerCamera = new GameObject("Controller UI Camera").AddComponent <Camera>();
ControllerCamera.transform.parent = Player.transform;
ControllerCamera.clearFlags = CameraClearFlags.Nothing;
ControllerCamera.cullingMask = 0; // 1 << LayerMask.NameToLayer("UI");
ControllerCamera.stereoTargetEye = StereoTargetEyeMask.None;
Cursors = new RectTransform[Player.Hands.Length];
Lasers = new LineRenderer[Cursors.Length];
for (int index = 0; index < Cursors.Length; index++)
{
GameObject cursor = new GameObject("Cursor for " + Player.Hands[index].gameObject.name);
cursor.transform.parent = this.transform;
cursor.transform.localPosition = Vector3.zero;
cursor.transform.localRotation = Quaternion.identity;
Canvas canvas = cursor.AddComponent <Canvas>();
cursor.AddComponent <CanvasRenderer>();
cursor.AddComponent <CanvasScaler>();
cursor.AddComponent <NVRUIIgnoreRaycast>();
cursor.AddComponent <GraphicRaycaster>();
canvas.renderMode = RenderMode.WorldSpace;
canvas.sortingOrder = 1000; //set to be on top of everything
Image image = cursor.AddComponent <Image>();
image.sprite = CursorSprite;
image.material = CursorMaterial;
if (LaserEnabled == true)
{
Lasers[index] = cursor.AddComponent <LineRenderer>();
Lasers[index].material = new Material(Shader.Find("Standard"));
Lasers[index].material.color = LaserColor;
NVRHelpers.LineRendererSetColor(Lasers[index], LaserColor, LaserColor);
NVRHelpers.LineRendererSetWidth(Lasers[index], LaserStartWidth, LaserEndWidth);
Lasers[index].useWorldSpace = true;
Lasers[index].enabled = false;
}
if (CursorSprite == null)
{
Debug.LogError("Set CursorSprite on " + this.gameObject.name + " to the sprite you want to use as your cursor.", this.gameObject);
}
Cursors[index] = cursor.GetComponent <RectTransform>();
}
CurrentPoint = new GameObject[Cursors.Length];
CurrentPressed = new GameObject[Cursors.Length];
CurrentDragging = new GameObject[Cursors.Length];
PointEvents = new PointerEventData[Cursors.Length];
Canvas[] canvases = GameObject.FindObjectsOfType <Canvas>();
foreach (Canvas canvas in canvases)
{
canvas.worldCamera = ControllerCamera;
}
Initialized = true;
}
}
public override void Initialize(NVRPlayer player)
{
Player = player;
UnityEngine.XR.InputTracking.Recenter();
}
public abstract void Initialize(NVRPlayer player);
public override void Initialize(NVRPlayer player)
{
Player = player;
Player.gameObject.SetActive(false);
OVRManager manager = Player.gameObject.AddComponent <OVRManager>();
manager.trackingOriginType = OVRManager.TrackingOrigin.FloorLevel;
// User OVR rig for two camera, per eye setup
OVRCameraRig rig = Player.gameObject.AddComponent <OVRCameraRig>();
rig.usePerEyeCameras = true;
NVRHelpers.SetProperty(rig, "trackingSpace", Player.transform, true);
NVRHelpers.SetProperty(rig, "leftHandAnchor", Player.LeftHand.transform, true);
NVRHelpers.SetProperty(rig, "rightHandAnchor", Player.RightHand.transform, true);
NVRHelpers.SetProperty(rig, "centerEyeAnchor", Player.Head.transform, true);
Player.gameObject.SetActive(true);
// Initialize Left and Right eye cameras with components and values matching original head camera
// This allows image effects, scripts, etc. set up and tested on the main camera to copy
// over maintaining values to two camera setup
// Reference to the NVR Head game object with desired camera components and values
GameObject originalHead = Player.Head.gameObject;
// Reference to left and right eye cameras created by OVR rig setup
Camera _leftEyeCamera = rig.leftEyeAnchor.GetComponent <Camera>();
Camera _rightEyeCamera = rig.rightEyeAnchor.GetComponent <Camera>();
if (originalHead != null)
{
///////////////////// LEFT EYE CAMERA SETUP //////////////////////////////
// Adjust clipping and target eye for stereo camera
_leftEyeCamera.stereoTargetEye = StereoTargetEyeMask.Left;
_leftEyeCamera.farClipPlane = 160f;
_leftEyeCamera.nearClipPlane = 0.01f;
// Background color setup //change to fix NewtonSubmodule link
// _leftEyeCamera.clearFlags = CameraClearFlags.SolidColor;
// _leftEyeCamera.backgroundColor = new Color(0.00f, 0.0f, 0.025f);
// Set all layers to 1, then compare with & to change "RightEye" layer to 0 while keeping all others 1
// 1111 add 1101 get 1101
_leftEyeCamera.cullingMask = originalHead.GetComponent <Camera>().cullingMask;
_leftEyeCamera.cullingMask &= ~(1 << LayerMask.NameToLayer("RightEye"));
// Copy over image effect components from the main camera tagged with "ArtSetupCamera"
// to each target eye camera with reflected component values
Component[] cameraComponents = originalHead.GetComponents(typeof(Component));
// Copy over each component from the head to the right eye
foreach (Component curComponent in cameraComponents)
{
// Get component type
System.Type type = curComponent.GetType();
// Skip certain components ie left eye already has Camera
// component and scene only needs one AudioListener
if (type != typeof(Camera) && type != typeof(Transform) &&
type != typeof(AudioListener))
{
// Add component to right eye game object
Component copy = rig.leftEyeAnchor.gameObject.AddComponent(type);
// Save active status of component from head
bool isActive = ((Behaviour)originalHead.GetComponent(type)).enabled;
// Reflect all component values from head to right eye
System.Reflection.FieldInfo[] fields = type.GetFields();
foreach (System.Reflection.FieldInfo field in fields)
{
field.SetValue(copy, field.GetValue(curComponent));
}
// Set active status of right eye component from status of head
((Behaviour)rig.leftEyeAnchor.GetComponent(type)).enabled = isActive;
}
}
///////////////////// RIGHT EYE CAMERA SETUP //////////////////////////////
// Adjust clipping and target eye for stereo camera
_rightEyeCamera.stereoTargetEye = StereoTargetEyeMask.Right;
_rightEyeCamera.farClipPlane = 160f;
_rightEyeCamera.nearClipPlane = 0.01f;
// Background color setup
// _rightEyeCamera.clearFlags = CameraClearFlags.SolidColor;
// _rightEyeCamera.backgroundColor = new Color(0.00f, 0.0f, 0.025f);
// Set all layers to 1, then compare with & to change "LeftEye" layer to 0 while keeping all others 1
// 1111 add 1101 get 1101
_rightEyeCamera.cullingMask = originalHead.GetComponent <Camera>().cullingMask;
_rightEyeCamera.cullingMask &= ~(1 << LayerMask.NameToLayer("LeftEye"));
_rightEyeCamera.tag = "MainCamera";
// Copy over image effect components from the main camera tagged with "ArtSetupCamera"
// to each target eye camera with reflected component values
// Component[] cameraComponents = originalHead.GetComponents(typeof(Component));
// Copy over each component from the head to the right eye
foreach (Component curComponent in cameraComponents)
{
// Get component type
System.Type type = curComponent.GetType();
// Skip certain components ie right eye already has Camera
// component and scene only needs one AudioListener
if (type != typeof(Camera) && type != typeof(Transform) &&
type != typeof(AudioListener))
{
// Add component to right eye game object
Component copy = rig.rightEyeAnchor.gameObject.AddComponent(type);
// Save active status of component from head
bool isActive = ((Behaviour)originalHead.GetComponent(type)).enabled;
// Reflect all component values from head to right eye
System.Reflection.FieldInfo[] fields = type.GetFields();
foreach (System.Reflection.FieldInfo field in fields)
{
field.SetValue(copy, field.GetValue(curComponent));
}
// Set active status of right eye component from status of head
((Behaviour)rig.rightEyeAnchor.GetComponent(type)).enabled = isActive;
}
}
}
}
protected override void Start()
{
base.Start();
player = GetComponent <NVRPlayer>();
if (Initialized == false)
{
Instance = this;
ControllerCamera = new GameObject("Controller UI Camera").AddComponent <Camera>();
ControllerCamera.transform.parent = player.transform;
ControllerCamera.stereoTargetEye = StereoTargetEyeMask.None;
ControllerCamera.clearFlags = CameraClearFlags.Nothing;
ControllerCamera.cullingMask = 0; // 1 << LayerMask.NameToLayer("UI");
Cursors = new RectTransform[player.Hands.Length];
for (int index = 0; index < Cursors.Length; index++)
{
GameObject cursor = new GameObject("Cursor for " + player.Hands[index].gameObject.name);
cursor.transform.parent = this.transform;
Canvas canvas = cursor.AddComponent <Canvas>();
cursor.AddComponent <CanvasRenderer>();
cursor.AddComponent <CanvasScaler>();
cursor.AddComponent <NVRUIIgnoreRaycast>();
cursor.AddComponent <GraphicRaycaster>();
canvas.renderMode = RenderMode.WorldSpace;
canvas.sortingOrder = 1000; //set to be on top of everything
Image image = cursor.AddComponent <Image>();
image.sprite = CursorSprite;
image.material = CursorMaterial;
if (CursorSprite == null)
{
Debug.LogError("Set CursorSprite on " + this.gameObject.name + " to the sprite you want to use as your cursor.", this.gameObject);
}
Cursors[index] = cursor.GetComponent <RectTransform>();
}
CurrentPoint = new GameObject[Cursors.Length];
CurrentPressed = new GameObject[Cursors.Length];
CurrentDragging = new GameObject[Cursors.Length];
PointEvents = new PointerEventData[Cursors.Length];
Canvas[] canvases = GameObject.FindObjectsOfType <Canvas>();
foreach (Canvas canvas in canvases)
{
/// HACK: Stop NVR from stealing our non-VR GUIs D:
if (canvas.transform.parent.name != "DesktopGUICamera")
{
canvas.worldCamera = ControllerCamera;
}
}
Initialized = true;
}
}
public override void Initialize(NVRPlayer player)
{
Player = player;
#if UNITY_5_6_OR_NEWER
Player.Head.gameObject.AddComponent <SteamVR_UpdatePoses>();
#endif
Player.gameObject.SetActive(false);
SteamVR_ControllerManager controllerManager = Player.gameObject.AddComponent <SteamVR_ControllerManager>();
controllerManager.left = Player.LeftHand.gameObject;
controllerManager.right = Player.RightHand.gameObject;
//Player.gameObject.AddComponent<SteamVR_PlayArea>();
for (int index = 0; index < Player.Hands.Length; index++)
{
Player.Hands[index].gameObject.AddComponent <SteamVR_TrackedObject>();
}
SteamVR_Camera steamVrCamera = Player.Head.gameObject.AddComponent <SteamVR_Camera>();
Player.Head.gameObject.AddComponent <SteamVR_Ears>();
NVRHelpers.SetField(steamVrCamera, "_head", Player.Head.transform, false);
NVRHelpers.SetField(steamVrCamera, "_ears", Player.Head.transform, false);
//// Start Integration for Holo with NVR //////
// Integration for two camera setup needed for Microsoft Holo video with NewtonVr
Player.Head.gameObject.name = "Head_Left"; // rename original NVR head to avoid confusion in editor
// Create game object and position it to match NVR existing camera
GameObject headRight = new GameObject("Head_Right");
headRight.transform.position = Player.Head.gameObject.transform.position;
headRight.transform.rotation = Player.Head.transform.rotation;
headRight.transform.parent = Player.Head.transform.parent;
// Add camera to new game object and set for right VR eye
Camera camRight = headRight.AddComponent <Camera> ();
camRight.stereoTargetEye = StereoTargetEyeMask.Right;
// Add steam camera component
//SteamVR_Camera steamVrCameraRight = headRight.gameObject.AddComponent<SteamVR_Camera>();
headRight.gameObject.AddComponent <SteamVR_Camera>();
// If original NVR head has a camera component, set the camera for left VR eye
Camera camLeft = Player.Head.GetComponent <Camera> ();
if (camLeft)
{
camLeft.stereoTargetEye = StereoTargetEyeMask.Left;
}
//// End Integration for Holo with NVR //////
Player.Head.gameObject.AddComponent <SteamVR_TrackedObject>();
Player.gameObject.SetActive(true);
SteamVR_Render[] steamvr_objects = GameObject.FindObjectsOfType <SteamVR_Render>();
for (int objectIndex = 0; objectIndex < steamvr_objects.Length; objectIndex++)
{
steamvr_objects[objectIndex].lockPhysicsUpdateRateToRenderFrequency = false; //this generally seems to break things :) Just make sure your Time -> Physics Timestep is set to 0.011
}
}
public override void OnInspectorGUI()
{
NVRPlayer player = (NVRPlayer)target;
if (PlayerPrefs.HasKey(CheckForUpdatesKey) == false || PlayerPrefs.GetInt(CheckForUpdatesKey) != System.Convert.ToInt32(player.NotifyOnVersionUpdate))
{
PlayerPrefs.SetInt("NewtonVRCheckForUpdates", System.Convert.ToInt32(player.NotifyOnVersionUpdate));
}
if (hasReloaded == false)
{
DidReloadScripts();
}
if (waitingForReload)
{
HasWaitedLongEnough();
}
player.OculusSDKEnabled = hasOculusSDKDefine;
//bool installOculusSDK = false;
bool enableOculusSDK = player.OculusSDKEnabled;
// Debug.Log("hasOculusSDK="+hasOculusSDK);
EditorGUILayout.BeginHorizontal();
enableOculusSDK = EditorGUILayout.Toggle("Enable Oculus SDK", player.OculusSDKEnabled);
EditorGUILayout.EndHorizontal();
GUILayout.Space(10);
GUILayout.Label("Model override for all SDKs");
bool modelOverrideAll = EditorGUILayout.Toggle("Override hand models for all SDKs", player.OverrideAll);
EditorGUILayout.BeginFadeGroup(1);
using (new EditorGUI.DisabledScope(modelOverrideAll == false))
{
player.OverrideAllLeftHand = (GameObject)EditorGUILayout.ObjectField("Left Hand", player.OverrideAllLeftHand, typeof(GameObject), false);
GUILayout.BeginHorizontal();
GUILayout.Space(20);
player.OverrideAllLeftHandPhysicalColliders = (GameObject)EditorGUILayout.ObjectField("Left Hand Physical Colliders", player.OverrideAllLeftHandPhysicalColliders, typeof(GameObject), false);
GUILayout.EndHorizontal();
player.OverrideAllRightHand = (GameObject)EditorGUILayout.ObjectField("Right Hand", player.OverrideAllRightHand, typeof(GameObject), false);
GUILayout.BeginHorizontal();
GUILayout.Space(20);
player.OverrideAllRightHandPhysicalColliders = (GameObject)EditorGUILayout.ObjectField("Right Hand Physical Colliders", player.OverrideAllRightHandPhysicalColliders, typeof(GameObject), false);
GUILayout.EndHorizontal();
}
EditorGUILayout.EndFadeGroup();
if (modelOverrideAll == true)
{
player.OverrideOculus = false;
}
if (player.OverrideAll != modelOverrideAll)
{
EditorUtility.SetDirty(target);
player.OverrideAll = modelOverrideAll;
}
GUILayout.Space(10);
//if (player.OculusSDKEnabled == true)
//{
// GUILayout.Label("Model override for Oculus SDK");
// using (new EditorGUI.DisabledScope(hasOculusSDK == false))
// {
// bool modelOverrideOculus = EditorGUILayout.Toggle("Override hand models for Oculus SDK", player.OverrideOculus);
// EditorGUILayout.BeginFadeGroup(Convert.ToSingle(modelOverrideOculus));
// using (new EditorGUI.DisabledScope(modelOverrideOculus == false))
// {
// player.OverrideOculusLeftHand = (GameObject)EditorGUILayout.ObjectField("Left Hand", player.OverrideOculusLeftHand, typeof(GameObject), false);
// GUILayout.BeginHorizontal();
// GUILayout.Space(20);
// player.OverrideOculusLeftHandPhysicalColliders = (GameObject)EditorGUILayout.ObjectField("Left Hand Physical Colliders", player.OverrideOculusLeftHandPhysicalColliders, typeof(GameObject), false);
// GUILayout.EndHorizontal();
// player.OverrideOculusRightHand = (GameObject)EditorGUILayout.ObjectField("Right Hand", player.OverrideOculusRightHand, typeof(GameObject), false);
// GUILayout.BeginHorizontal();
// GUILayout.Space(20);
// player.OverrideOculusRightHandPhysicalColliders = (GameObject)EditorGUILayout.ObjectField("Right Hand Physical Colliders", player.OverrideOculusRightHandPhysicalColliders, typeof(GameObject), false);
// GUILayout.EndHorizontal();
// }
// EditorGUILayout.EndFadeGroup();
// if (modelOverrideOculus == true)
// {
// player.OverrideAll = false;
// }
// if (player.OverrideOculus != modelOverrideOculus)
// {
// EditorUtility.SetDirty(target);
// player.OverrideOculus = modelOverrideOculus;
// }
// }
//}
GUILayout.Space(10);
if (enableOculusSDK == false && player.OculusSDKEnabled == true)
{
RemoveDefine(OculusDefine);
}
else if (enableOculusSDK == true && player.OculusSDKEnabled == false)
{
AddDefine(OculusDefine);
}
DrawDefaultInspector();
if (waitingForReload == true || string.IsNullOrEmpty(progressBarMessage) == false)
{
DisplayProgressBar();
}
if (GUI.changed)
{
if (Application.isPlaying == false)
{
EditorUtility.SetDirty(target);
EditorSceneManager.MarkSceneDirty(SceneManager.GetActiveScene());
}
}
}
public override void Initialize(NVRPlayer player)
{
Debug.LogError("Oculus not supported.");
}
public override void Initialize(NVRPlayer player)
{
}
public override void Initialize(NVRPlayer player)
{
Player = player;
Player.gameObject.SetActive(true);
}
public override void Initialize(NVRPlayer player)
{
//// Start Integration for Stereo with NVR //////
NVRPlayer Player = player;
Debug.Log("init gear");
// Integration for two camera setup needed for Microsoft Holo video with NewtonVr
Player.Head.gameObject.name = "Head_Left"; // rename original NVR head to avoid confusion in editor
// Create game object and position it to match NVR existing camera
GameObject headRight = new GameObject("Head_Right");
// headRight.gameObject.tag = "MainCamera";
headRight.transform.position = Player.Head.gameObject.transform.position;
headRight.transform.rotation = Player.Head.transform.rotation;
headRight.transform.parent = Player.Head.transform.parent;
// Add camera to new game object and set for right VR eye
Camera camRight = headRight.AddComponent <Camera>();
camRight.stereoTargetEye = StereoTargetEyeMask.Right;
camRight.cullingMask = Player.Head.GetComponent <Camera>().cullingMask;
camRight.cullingMask &= ~(1 << 8);
camRight.farClipPlane = 160f;
camRight.nearClipPlane = 0.01f;
camRight.allowHDR = true;
camRight.depth = -1;
// If original NVR head has a camera component, set the camera for left VR eye
Camera camLeft = Player.Head.GetComponent <Camera>();
if (camLeft)
{
camLeft.stereoTargetEye = StereoTargetEyeMask.Left;
// Set all layers to 1, then compare with & to change "RightEye" layer to 0 while keeping all others 1
// 1111 add 1101 get 1101
camLeft.cullingMask &= ~(1 << 9);
camLeft.farClipPlane = 160f;
camLeft.nearClipPlane = 0.01f;
camLeft.allowHDR = true;
}
// Copy over image effect components from the main camera tagged with "ArtSetupCamera"
// to each target eye camera with reflected component values
Component[] cameraComponents = Player.Head.GetComponents(typeof(Component));
// Copy over each component from the head to the right eye
foreach (Component curComponent in cameraComponents)
{
// Get component type
System.Type type = curComponent.GetType();
// Skip certain components ie left eye already has Camera
// component and scene only needs one AudioListener
if (type != typeof(Camera) && type != typeof(Transform) &&
type != typeof(AudioListener))// && type != typeof(VideoPlayTest))
{
// Add component to right eye game object
Component copy = headRight.AddComponent(type);
// Save active status of component from head
bool isActive = ((Behaviour)Player.Head.GetComponent(type)).enabled;
// Reflect all component values from head to right eye
System.Reflection.FieldInfo[] fields = type.GetFields();
foreach (System.Reflection.FieldInfo field in fields)
{
field.SetValue(copy, field.GetValue(curComponent));
}
// Set active status of right eye component from status of head
((Behaviour)headRight.GetComponent(type)).enabled = isActive;
}
}
isOculusGo = SystemInfo.deviceModel == "Oculus Pacific";
Debug.Log("Is Oculus go " + isOculusGo + " Device model " + SystemInfo.deviceModel);
if (isOculusGo)
{
UnityEngine.VR.VRSettings.renderScale = 1.2f;
}
//// End Integration for Stereo with NVR //////
}
public virtual void PreInitialize(NVRPlayer player)
{
Player = player;
IsRight = Player.RightHand == this;
IsLeft = Player.LeftHand == this;
CurrentInteractionStyle = Player.InteractionStyle;
CurrentlyHoveringOver = new Dictionary <NVRInteractable, Dictionary <Collider, float> >();
LastPositions = new Vector3[EstimationSamples];
LastRotations = new Quaternion[EstimationSamples];
LastDeltas = new float[EstimationSamples];
EstimationSampleIndex = 0;
VisibilityLocked = false;
Inputs = new Dictionary <NVRButtons, NVRButtonInputs>(new NVRButtonsComparer());
for (int buttonIndex = 0; buttonIndex < NVRButtonsHelper.Array.Length; buttonIndex++)
{
if (Inputs.ContainsKey(NVRButtonsHelper.Array[buttonIndex]) == false)
{
Inputs.Add(NVRButtonsHelper.Array[buttonIndex], new NVRButtonInputs());
}
}
if (Player.CurrentIntegrationType == NVRSDKIntegrations.Oculus)
{
InputDevice = this.gameObject.AddComponent <NVROculusInputDevice>();
if (Player.OverrideOculus == true)
{
if (IsLeft)
{
CustomModel = Player.OverrideOculusLeftHand;
CustomPhysicalColliders = Player.OverrideOculusLeftHandPhysicalColliders;
}
else if (IsRight)
{
CustomModel = Player.OverrideOculusRightHand;
CustomPhysicalColliders = Player.OverrideOculusRightHandPhysicalColliders;
}
else
{
Debug.LogError("[NewtonVR] Error: Unknown hand for oculus model override.");
}
}
}
else if (Player.CurrentIntegrationType == NVRSDKIntegrations.SteamVR)
{
InputDevice = this.gameObject.AddComponent <NVRSteamVRInputDevice>();
if (Player.OverrideSteamVR == true)
{
if (IsLeft)
{
CustomModel = Player.OverrideSteamVRLeftHand;
CustomPhysicalColliders = Player.OverrideSteamVRLeftHandPhysicalColliders;
}
else if (IsRight)
{
CustomModel = Player.OverrideSteamVRRightHand;
CustomPhysicalColliders = Player.OverrideSteamVRRightHandPhysicalColliders;
}
else
{
Debug.LogError("[NewtonVR] Error: Unknown hand for SteamVR model override.");
}
}
}
else
{
//Debug.LogError("[NewtonVR] Critical Error: NVRPlayer.CurrentIntegration not setup.");
return;
}
if (Player.OverrideAll)
{
if (IsLeft)
{
CustomModel = Player.OverrideAllLeftHand;
CustomPhysicalColliders = Player.OverrideAllLeftHandPhysicalColliders;
}
else if (IsRight)
{
CustomModel = Player.OverrideAllRightHand;
CustomPhysicalColliders = Player.OverrideAllRightHandPhysicalColliders;
}
else
{
Debug.LogError("[NewtonVR] Error: Unknown hand for SteamVR model override.");
return;
}
}
InputDevice.Initialize(this);
InitializeRenderModel();
}
public virtual void PreInitialize(NVRPlayer player)
{
Player = player;
IsRight = Player.RightHand == this;
IsLeft = Player.LeftHand == this;
CurrentInteractionStyle = Player.InteractionStyle;
CurrentlyHoveringOver = new Dictionary <NVRInteractable, Dictionary <Collider, float> >();
LastPositions = new Vector3[EstimationSamples];
LastRotations = new Quaternion[EstimationSamples];
LastDeltas = new float[EstimationSamples];
EstimationSampleIndex = 0;
VisibilityLocked = false;
// If we already have an input device attached to this object, use that.
if (Player.CurrentIntegrationType == NVRSDKIntegrations.Oculus)
{
if (Player.OverrideOculus)
{
if (IsLeft)
{
CustomModel = Player.OverrideOculusLeftHand;
CustomPhysicalColliders = Player.OverrideOculusLeftHandPhysicalColliders;
}
else if (IsRight)
{
CustomModel = Player.OverrideOculusRightHand;
CustomPhysicalColliders = Player.OverrideOculusRightHandPhysicalColliders;
}
else
{
Debug.LogError("[NewtonVR] Error: Unknown hand for oculus model override.");
}
}
}
else if (Player.CurrentIntegrationType == NVRSDKIntegrations.SteamVR)
{
if (Player.OverrideSteamVR)
{
if (IsLeft)
{
CustomModel = Player.OverrideSteamVRLeftHand;
CustomPhysicalColliders = Player.OverrideSteamVRLeftHandPhysicalColliders;
}
else if (IsRight)
{
CustomModel = Player.OverrideSteamVRRightHand;
CustomPhysicalColliders = Player.OverrideSteamVRRightHandPhysicalColliders;
}
else
{
Debug.LogError("[NewtonVR] Error: Unknown hand for SteamVR model override.");
}
}
}
else
{
Debug.LogError("[NewtonVR] Error: NVRPlayer.CurrentIntegration not setup.");
return;
}
if (Player.OverrideAll)
{
if (IsLeft)
{
CustomModel = Player.OverrideAllLeftHand;
CustomPhysicalColliders = Player.OverrideAllLeftHandPhysicalColliders;
}
else if (IsRight)
{
CustomModel = Player.OverrideAllRightHand;
CustomPhysicalColliders = Player.OverrideAllRightHandPhysicalColliders;
}
else
{
Debug.LogError("[NewtonVR] Error: Unknown hand for SteamVR model override.");
}
}
}
