public override void Install(bool reset)
{
base.Install(reset);
#if UNITY_EDITOR
if (ARBackgroundMaterial == null || reset)
{
ARBackgroundMaterial = ResourceExt.EditorLoadAsset <Material>("Assets/GoogleARCore/SDK/Materials/ARBackground.mat");
}
#endif
if (arCoreSession == null)
{
arCoreSession = this.Ensure <ARCoreSession>().Value;
arCoreSession.SessionConfig = ScriptableObject.CreateInstance <ARCoreSessionConfig>();
arCoreSession.SessionConfig.MatchCameraFramerate = true;
}
if (bgRenderer == null)
{
bgRenderer = this.Ensure <ARCoreBackgroundRenderer>().Value;
bgRenderer.BackgroundMaterial = ARBackgroundMaterial;
}
if (poseDriver == null)
{
poseDriver = this.Ensure <TrackedPoseDriver>().Value;
poseDriver.SetPoseSource(TrackedPoseDriver.DeviceType.GenericXRDevice, TrackedPoseDriver.TrackedPose.ColorCamera);
poseDriver.trackingType = TrackedPoseDriver.TrackingType.RotationAndPosition;
poseDriver.updateType = TrackedPoseDriver.UpdateType.BeforeRender;
poseDriver.UseRelativeTransform = true;
}
}
void Awake()
{
this.driver = this.gameObject.GetComponent <TrackedPoseDriver>();
// The color camera of a mobile device
this.driver.SetPoseSource(TrackedPoseDriver.DeviceType.GenericXRDevice, TrackedPoseDriver.TrackedPose.ColorCamera);
}
void Awake()
{
cam = cameraTransform.GetComponent <Camera>();
poseDriver = cameraTransform.GetComponent <TrackedPoseDriver>();
defaultFov = cam.fieldOfView;
initialRotation = cameraTransform.rotation;
}
private void Awake()
{
cameraObject_ = new GameObject("VR Camera");
cameraObject_.transform.parent = transform;
camera_ = cameraObject_.AddComponent <Camera>();
cameraObject_.AddComponent <AudioListener>();
// TODO Get camera settings
CopyCameraSettings();
leftController_ = GameObject.CreatePrimitive(PrimitiveType.Cube);
leftController_.transform.parent = transform;
leftController_.GetComponent <BoxCollider>().isTrigger = true;
leftController_.transform.localScale = Vector3.one * 0.1f;
left_ = leftController_.AddComponent <TrackedPoseDriver>();
left_.SetPoseSource(TrackedPoseDriver.DeviceType.GenericXRController, TrackedPoseDriver.TrackedPose.LeftPose);
rightController_ = GameObject.CreatePrimitive(PrimitiveType.Cube);
rightController_.transform.parent = transform;
rightController_.GetComponent <BoxCollider>().isTrigger = true;
rightController_.transform.localScale = Vector3.one * 0.1f;
right_ = rightController_.AddComponent <TrackedPoseDriver>();
right_.SetPoseSource(TrackedPoseDriver.DeviceType.GenericXRController, TrackedPoseDriver.TrackedPose.RightPose);
InputTracking.nodeAdded += InputTracking_nodeAdded;
InputTracking.nodeRemoved += InputTracking_nodeRemoved;
StartCoroutine(LoadDevice("OpenVR"));
}
// Use this for initialization
void Start()
{
arOrigin = FindObjectOfType <ARSessionOrigin>();
ARSessionOrigin = arOrigin.GetComponent <ARSessionOrigin>();
inOtherWorld = portalWindow.GetComponent <PortalOther> ();
tracked = device.GetComponent <TrackedPoseDriver>();
}
void Awake()
{
// get the components
trackedPoseDriver = GetComponent <TrackedPoseDriver>();
axisController = GetComponent <AxisController>();
buttonController = GetComponent <ButtonController>();
}
void OnValidate()
{
if (driver == null)
{
driver = FindObjectOfType <TrackedPoseDriver>();
}
}
static bool CreateSimpleXRRig(Camera xrCamera, out GameObject gameObj)
{
var xrRigGO = ObjectFactory.CreateGameObject("XRRig");
var cameraOffsetGO = ObjectFactory.CreateGameObject("Camera Offset");
Undo.SetTransformParent(cameraOffsetGO.transform, xrRigGO.transform, "Parent Camera Offset to XR Rig");
Pose camPose = new Pose();
// we only want to move the rig to the camera position if one is passed in.
bool camExistsAndNeedsMoving = false;
if (xrCamera == null)
{
var xrCameraGO = ObjectFactory.CreateGameObject("Main Camera", typeof(Camera));
xrCamera = xrCameraGO.GetComponent <Camera>();
}
else
{
camPose.position = xrCamera.transform.position;
// if initial camera position, move to the floor
if (camPose.position == kDefaultCameraPosition)
{
camPose.position.y = 0.0f;
}
camPose.rotation = xrCamera.transform.rotation;
camExistsAndNeedsMoving = true;
}
Undo.SetTransformParent(xrCamera.transform, cameraOffsetGO.transform, "Parent Camera to Camera Offset");
xrCamera.transform.localPosition = Vector3.zero;
xrCamera.transform.localRotation = Quaternion.identity;
xrCamera.tag = kMainCamera;
if (camExistsAndNeedsMoving)
{
xrRigGO.transform.position = camPose.position;
xrRigGO.transform.rotation = camPose.rotation;
}
TrackedPoseDriver trackedPoseDriver = xrCamera.gameObject.GetComponent <TrackedPoseDriver>();
if (trackedPoseDriver == null)
{
trackedPoseDriver = Undo.AddComponent <TrackedPoseDriver>(xrCamera.gameObject);
}
trackedPoseDriver.SetPoseSource(TrackedPoseDriver.DeviceType.GenericXRDevice, TrackedPoseDriver.TrackedPose.Center);
trackedPoseDriver.UseRelativeTransform = false;
var coh = xrRigGO.AddComponent <CameraOffset>();
coh.cameraFloorOffsetObject = cameraOffsetGO;
#if UNITY_2019_3_OR_NEWER
coh.TrackingOriginMode = UnityEngine.XR.TrackingOriginModeFlags.Device;
#else
coh.trackingSpace = UnityEngine.XR.TrackingSpaceType.Stationary;
#endif
gameObj = xrRigGO;
return(true);
}
/// <summary>
/// Uninitialize and clean up AR Foundation components.
/// </summary>
private void UninitializeARFoundation()
{
if (!isInitialized)
{
return;
}
if (!preExistingArSessionOriginObject &&
(arSessionOriginObject != null))
{
UnityObjectExtensions.DestroyObject(trackedPoseDriver);
trackedPoseDriver = null;
UnityObjectExtensions.DestroyObject(arCameraBackground);
arCameraBackground = null;
UnityObjectExtensions.DestroyObject(arCameraManager);
arCameraManager = null;
UnityObjectExtensions.DestroyObject(arSessionOrigin);
arSessionOrigin = null;
}
if (!preExistingArSessionObject &&
(arSessionObject != null))
{
UnityObjectExtensions.DestroyObject(arInputManager);
arInputManager = null;
UnityObjectExtensions.DestroyObject(arSession);
arSession = null;
UnityObjectExtensions.DestroyObject(arSessionObject);
arSessionObject = null;
}
isInitialized = false;
}
// Start is called before the first frame update
void Start()
{
if (driver == null)
{
driver = GetComponent <TrackedPoseDriver> ();
}
driver.trackingType = TrackedPoseDriver.TrackingType.RotationAndPosition;
}
private void Start()
{
if (tpd == null)
{
tpd = GetComponent <TrackedPoseDriver>();
}
m_Transform = GetComponent <Transform>();
}
/// <inheritdoc />
public override void Disable()
{
if (trackedPoseDriver != null)
{
Object.Destroy(trackedPoseDriver);
trackedPoseDriver = null;
}
base.Disable();
}
/// <inheritdoc />
public override void Disable()
{
if (trackedPoseDriver != null)
{
UnityObjectExtensions.DestroyObject(trackedPoseDriver);
trackedPoseDriver = null;
}
base.Disable();
}
// Start is called before the first frame update
void Start()
{
trackedPose = GetComponent <TrackedPoseDriver>();
positionHolder = holder.worldToLocalMatrix.MultiplyPoint(this.transform.position);
rotationHolder = this.transform.rotation * Quaternion.Inverse(holder.rotation);
rb.useGravity = false;
rb.maxAngularVelocity = Mathf.Infinity;
}
/// <inheritdoc/>
public override void Enable()
{
base.Enable();
// Only track the TrackedPoseDriver if we added it ourselves.
// There may be a pre-configured TrackedPoseDriver on the camera.
if (!CameraCache.Main.GetComponent <TrackedPoseDriver>())
{
trackedPoseDriver = CameraCache.Main.gameObject.AddComponent <TrackedPoseDriver>();
}
}
private void Start()
{
tpd = GetComponent <TrackedPoseDriver>();
nodeType = tpd.poseSource == TrackedPoseDriver.TrackedPose.RightPose ? XRNode.RightHand : XRNode.LeftHand;
m_Transform = GetComponent <Transform>();
if (XRSettings.loadedDeviceName == "daydream")
{
m_Transform.localPosition = new Vector3(right, up, forward);
}
}
private void Start()
{
m_MainCamera = Camera.main;
if (Application.isEditor)
{
TrackedPoseDriver tpd = m_MainCamera.GetComponent <TrackedPoseDriver>();
if (tpd)
{
tpd.enabled = false;
}
}
}
private void PrepareGraphicsLayerCamera()
{
m_trackedPoseDriver = m_editorWindow.Camera.GetComponent <TrackedPoseDriver>();
if (m_editorWindow.Editor.IsVR && m_editorWindow.Camera.stereoEnabled && m_editorWindow.Camera.stereoTargetEye == StereoTargetEyeMask.Both)
{
bool wasActive = m_editorWindow.Camera.gameObject.activeSelf;
m_editorWindow.Camera.gameObject.SetActive(false);
m_graphicsLayerCamera = Instantiate(m_editorWindow.Camera, m_editorWindow.Camera.transform.parent);
m_graphicsLayerCamera.transform.SetSiblingIndex(m_editorWindow.Camera.transform.GetSiblingIndex() + 1);
m_editorWindow.Camera.gameObject.SetActive(wasActive);
m_graphicsLayerCamera.gameObject.SetActive(wasActive);
}
else
{
m_graphicsLayerCamera = Instantiate(m_editorWindow.Camera, m_editorWindow.Camera.transform);
}
for (int i = m_graphicsLayerCamera.transform.childCount - 1; i >= 0; i--)
{
Destroy(m_graphicsLayerCamera.transform.GetChild(i).gameObject);
}
Component[] components = m_graphicsLayerCamera.GetComponents <Component>();
for (int i = 0; i < components.Length; ++i)
{
Component component = components[i];
if (component is Transform)
{
continue;
}
if (component is Camera)
{
continue;
}
Destroy(component);
}
m_graphicsLayerCamera.clearFlags = CameraClearFlags.Depth;
m_graphicsLayerCamera.transform.localPosition = Vector3.zero;
m_graphicsLayerCamera.transform.localRotation = Quaternion.identity;
m_graphicsLayerCamera.transform.localScale = Vector3.one;
m_graphicsLayerCamera.name = "GraphicsLayerCamera";
m_graphicsLayerCamera.depth = m_editorWindow.Camera.depth + 1;
m_graphicsLayerCamera.cullingMask = 1 << (m_editorWindow.Editor.CameraLayerSettings.RuntimeGraphicsLayer + m_editorWindow.Index);
if (m_trackedPoseDriver != null)
{
m_graphicsLayerCamera.projectionMatrix = m_editorWindow.Camera.projectionMatrix;
}
}
public void GrabObject(GameObject Object)
{
Object.transform.position = Vector3.zero;
Object.transform.rotation = Quaternion.identity;
pivot.transform.rotation = Quaternion.identity;
GrabbableObjects go = Object.GetComponent <GrabbableObjects>();
//pivot.transform.Rotate( go.GetGrabRotation());
TrackedPoseDriver tpd = Object.AddComponent <TrackedPoseDriver>();
tpd.UseRelativeTransform = true;
tpd.poseProviderComponent = bpp;
}
private void Start()
{
m_MainCamera = Camera.main;
m_Sdk = ImmersalARCloudSDK.Instance;
m_Loc = m_Sdk.gameObject.GetComponent <ARLocalizer>();
#if UNITY_EDITOR || UNITY_STANDALONE
TrackedPoseDriver tpd = m_MainCamera.GetComponent <TrackedPoseDriver>();
if (tpd)
{
tpd.enabled = false;
}
#endif
Vector3 pos = transform.position;
transform.position = pos;
}
void Start()
{
tracker = GetComponent <TrackedPoseDriver>();
if (tracker.poseSource == TrackedPoseDriver.TrackedPose.LeftPose)
{
handedness = InteractionSourceHandedness.Left;
}
else
{
handedness = InteractionSourceHandedness.Right;
}
InteractionManager.InteractionSourcePressed += InteractionManager_InteractionSourcePressed;
InteractionManager.InteractionSourceReleased += InteractionManager_InteractionSourceReleased;
InteractionManager.InteractionSourceUpdated += InteractionManager_InteractionSourceUpdated;
}
private void Awake()
{
poseDriver = GetComponent <TrackedPoseDriver>();
controllers = new List <InputDevice>();
nodes = new List <XRNodeState>();
if (Right)
{
node = XRNode.RightHand;
}
if (Left)
{
node = XRNode.LeftHand;
}
initialised = false;
}
/// <summary>
/// Initialize AR Foundation components.
/// </summary>
/// <remarks>
/// This method ensures AR Foundation required components (ex: AR Session, Tracked Pose Driver, etc) are
/// exist or are added to the appropriate scene objects. These components are used by AR Foundation to
/// communicate with the underlying AR platform (ex: AR Core), track the device and perform other necessary tasks.
/// </remarks>
private void InitializeARFoundation()
{
if (!isSupportedArConfiguration)
{
return;
}
if (isInitialized)
{
return;
}
FindARFoundationComponents();
if (arSessionObject == null)
{
arSessionObject = new GameObject("AR Session");
arSessionObject.transform.parent = null;
}
arSession = arSessionObject.EnsureComponent <ARSession>();
arInputManager = arSessionObject.EnsureComponent <ARInputManager>();
if (arSessionOriginObject == null)
{
arSessionOriginObject = MixedRealityPlayspace.Transform.gameObject;
}
CameraCache.Main.transform.parent = arSessionOriginObject.transform;
arSessionOrigin = arSessionOriginObject.EnsureComponent <ARSessionOrigin>();
arSessionOrigin.camera = CameraCache.Main;
GameObject cameraObject = arSessionOrigin.camera.gameObject;
arCameraManager = cameraObject.EnsureComponent <ARCameraManager>();
arCameraBackground = cameraObject.EnsureComponent <ARCameraBackground>();
trackedPoseDriver = cameraObject.EnsureComponent <TrackedPoseDriver>();
trackedPoseDriver.SetPoseSource(
TrackedPoseDriver.DeviceType.GenericXRDevice,
ArEnumConversion.ToUnityTrackedPose(poseSource));
trackedPoseDriver.trackingType = ArEnumConversion.ToUnityTrackingType(trackingType);
trackedPoseDriver.updateType = ArEnumConversion.ToUnityUpdateType(updateType);
trackedPoseDriver.UseRelativeTransform = false;
isInitialized = true;
}
void Start()
{
pose = GetComponent <TrackedPoseDriver>();
if (!pose)
{
pose = gameObject.AddComponent <TrackedPoseDriver>();
}
switch (type)
{
case HandType.right:
pose.SetPoseSource(TrackedPoseDriver.DeviceType.GenericXRController, TrackedPoseDriver.TrackedPose.RightPose);
break;
case HandType.left:
pose.SetPoseSource(TrackedPoseDriver.DeviceType.GenericXRController, TrackedPoseDriver.TrackedPose.LeftPose);
break;
}
}
private void OnEnable()
{
if (tpd == null)
{
tpd = GetComponent <TrackedPoseDriver>();
}
if (transformee == null)
{
transformee = GetComponent <Transform>();
}
Debug.Log("VR Device: " + XRSettings.loadedDeviceName);
if (XRSettings.loadedDeviceName == "daydream" || XRSettings.loadedDeviceName == "cardboard")
{
transformee.Translate(Vector3.up * playerHeight);
}
}
public void Throw(Vector3 hand, Vector3 handLastPosition, Quaternion handRotation)//Se usa la pos de la mano para dejar el objeto ahy, la ultima pos de la mano para calcular la vel y la rotación para dejarlo con la rotaión actual de la mano
{
TrackedPoseDriver tpd = GetComponent <TrackedPoseDriver>();
Destroy(tpd);
Rigidbody rb = GetComponent <Rigidbody>();
this.GetComponent <Collider>().enabled = true;
if (KeyObject == 0)
{
transform.position = _initialPosition;
}
else if (KeyObject == 1)
{
transform.position = hand;
transform.rotation = handRotation;
Vector3 CurrentVelocity = (hand - handLastPosition) / Time.deltaTime;
rb.velocity = CurrentVelocity * _MultiplyVeloc;
rb.useGravity = true;
}
else if (KeyObject == 2)
{
if (DejaLinterna)
{
transform.position = transformBolsillo.position;
transform.rotation = transformBolsillo.rotation;
rb.isKinematic = true;
}
else
{
transform.position = hand;
transform.rotation = handRotation;
Vector3 CurrentVelocity = (hand - handLastPosition) / Time.deltaTime;
rb.velocity = CurrentVelocity * _MultiplyVeloc;
rb.useGravity = true;
rb.isKinematic = false;
}
}
SetGrabbed(false);
}
public void OnKeyDown(GameObject source, string signal)
{
//Check if key event came from this key
if (source != ourKey)
{
return;
}
foreach (var closeObject in closeObjects)
{
//Attempt to get TrackedPoseDriver
Transform parent = closeObject.transform.parent;
if (parent == null)
{
continue;
}
parent = parent.parent;
if (parent == null)
{
continue;
}
TrackedPoseDriver driver = parent.gameObject.GetComponent <TrackedPoseDriver>();
if (driver == null)
{
continue;
}
//Send haptic feedback
if (driver.poseSource == TrackedPoseDriver.TrackedPose.RightPose)
{
InputDevices.GetDeviceAtXRNode(XRNode.RightHand).SendHapticImpulse(0, 0.5f, 1);
}
else if (driver.poseSource == TrackedPoseDriver.TrackedPose.LeftPose)
{
InputDevices.GetDeviceAtXRNode(XRNode.LeftHand).SendHapticImpulse(0, 0.5f, 1);
}
}
}
public void AddTrackedPoseDriver(HandVR handVR, Vector3 attachPositionOffset, Quaternion attachRotationOffset)
{
transform.parent = null;
transform.position = Vector3.zero;
transform.rotation = Quaternion.identity;
//TrackedPoseDriver tpd = gameObject.AddComponent<TrackedPoseDriver>();
//Just in case... check if already has a trackedPoseProvider
TrackedPoseDriver tpd = gameObject.GetComponent <TrackedPoseDriver>();
if (!tpd)
{
tpd = gameObject.AddComponent <TrackedPoseDriver>();
}
tpd.UseRelativeTransform = true;
handVR.PoseProvider.AttachPositionOffset = attachPositionOffset;
handVR.PoseProvider.AttachRotationOffset = attachRotationOffset;
tpd.poseProviderComponent = handVR.PoseProvider;
}
void DisableTracking()
{
TrackedPoseDriver tpd = GetComponent <TrackedPoseDriver>();
ARCoreSession session = GetComponent <ARCoreSession>();
InstantPreviewTrackedPoseDriver iptpd = GetComponent <InstantPreviewTrackedPoseDriver>();
if (tpd)
{
tpd.enabled = false;
}
if (session)
{
session.enabled = false;
}
if (iptpd)
{
iptpd.enabled = false;
}
tracking = false;
Debug.Log("Tracking Disabled");
}
private void Awake()
{
_currentHealth = maxHealth;
if (!photonView.IsMine)
{
return;
}
_playerAvatar = PhotonNetwork.Instantiate(Path.Combine("PhotonPrefabs", "PlayerAvatar"),
Vector3.zero, Quaternion.identity).GetComponent <AvatarSetup>();
_playerAvatar.SetPhotonPlayer(photonView.ViewID);
Debug.Log($"##### Photon player id: {PhotonNetwork.LocalPlayer.UserId}");
_camera = FindObjectOfType <TrackedPoseDriver>();
if (_camera == null)
{
Debug.LogError("First person camera not found!");
}
PhotonRoom.Instance.AddPhotonPlayer(this);
}
