/// <summary> /// Gets the <see cref="ARReferencePoint"/> with given <paramref name="trackableId"/>, /// or <c>null</c> if it does not exist. /// </summary> /// <param name="trackableId">The <see cref="TrackableId"/> of the <see cref="ARReferencePoint"/> to retrieve.</param> /// <returns>The <see cref="ARReferencePoint"/> with <paramref name="trackableId"/> or <c>null</c> if it does not exist.</returns> public ARReferencePoint GetReferencePoint(TrackableId trackableId) { ARReferencePoint referencePoint; if (m_Trackables.TryGetValue(trackableId, out referencePoint)) { return(referencePoint); } return(null); }
private void GetWallPlacement(ARRaycastHit _planeHit, out Quaternion orientation, out Quaternion zUp) { TrackableId planeHit_ID = _planeHit.trackableId; ARPlane planeHit = planeManager.GetPlane(planeHit_ID); Vector3 planeNormal = planeHit.normal; orientation = Quaternion.FromToRotation(Vector3.up, planeNormal); Vector3 forward = _planeHit.pose.position - (_planeHit.pose.position + Vector3.down); zUp = Quaternion.LookRotation(forward, planeNormal); }
protected override void OnRemoveIconClicked() { base.OnRemoveIconClicked(); // reset placed to allow new placement imagePlaced = false; placedPlaneId = TrackableId.InvalidId; // show tracked planes ARSessionOrigin.trackablesParent.gameObject.SetActive(true); }
/// <summary> /// Gets the <see cref="ARAnchor"/> with given <paramref name="trackableId"/>, /// or <c>null</c> if it does not exist. /// </summary> /// <param name="trackableId">The <see cref="TrackableId"/> of the <see cref="ARAnchor"/> to retrieve.</param> /// <returns>The <see cref="ARAnchor"/> with <paramref name="trackableId"/> or <c>null</c> if it does not exist.</returns> public ARAnchor GetAnchor(TrackableId trackableId) { ARAnchor anchor; if (m_Trackables.TryGetValue(trackableId, out anchor)) { return(anchor); } return(null); }
/// <summary> /// Attempts to find the environment probe matching the trackable ID currently in the scene. /// </summary> /// <param name='trackableId'>The trackable ID of an environment probe for which to search.</param> /// <returns> /// Environment probe in the scene matching the <paramref name="trackableId"/> or <c>null</c> if no matching /// environment probe is found. /// </returns> public AREnvironmentProbe GetEnvironmentProbe(TrackableId trackableId) { AREnvironmentProbe environmentProbe; if (m_Trackables.TryGetValue(trackableId, out environmentProbe)) { return(environmentProbe); } return(null); }
/// <summary> /// Attempt to retrieve an existing <see cref="ARPlane"/> by <paramref name="trackableId"/>. /// </summary> /// <param name="trackableId">The <see cref="TrackableId"/> of the plane to retrieve.</param> /// <returns>The <see cref="ARPlane"/> with <paramref name="trackableId"/>, or <c>null</c> if it does not exist.</returns> public ARPlane GetPlane(TrackableId trackableId) { ARPlane plane; if (m_Trackables.TryGetValue(trackableId, out plane)) { return(plane); } return(null); }
/// <summary> /// Get the human body matching the trackable identifier. /// </summary> /// <param name="trackableId">The trackable identifier for querying a human body trackable.</param> /// <returns> /// The human body trackable, if found. Otherwise, <c>null</c>. /// </returns> public ARHumanBody GetHumanBody(TrackableId trackableId) { ARHumanBody humanBody; if (m_Trackables.TryGetValue(trackableId, out humanBody)) { return(humanBody); } return(null); }
public unsafe override void GetFaceMesh( TrackableId faceId, Allocator allocator, ref XRFaceMesh faceMesh) { int vertexCount, triangleCount; void *vertexPtr, normalPtr, indexPtr, uvPtr; if (!UnityARCore_faceTracking_TryGetFaceData( faceId, out vertexPtr, out normalPtr, out uvPtr, out vertexCount, out indexPtr, out triangleCount)) { faceMesh.Dispose(); faceMesh = default(XRFaceMesh); return; } faceMesh.Resize( vertexCount, triangleCount, XRFaceMesh.Attributes.Normals | XRFaceMesh.Attributes.UVs, allocator); var vertexJobHandle = new TransformVerticesJob { verticesIn = NativeArrayUnsafeUtility.ConvertExistingDataToNativeArray <Vector3>(vertexPtr, vertexCount, Allocator.None), verticesOut = faceMesh.vertices }.Schedule(vertexCount, 32); var normalJobHandle = new TransformVerticesJob { verticesIn = NativeArrayUnsafeUtility.ConvertExistingDataToNativeArray <Vector3>(normalPtr, vertexCount, Allocator.None), verticesOut = faceMesh.normals }.Schedule(vertexCount, 32); var uvJobHandle = new TransformUVsJob { uvsIn = NativeArrayUnsafeUtility.ConvertExistingDataToNativeArray <Vector2>(uvPtr, vertexCount, Allocator.None), uvsOut = faceMesh.uvs }.Schedule(vertexCount, 32); var indexJobHandle = new TransformIndicesJob { triangleIndicesIn = NativeArrayUnsafeUtility.ConvertExistingDataToNativeArray <Triangle <ushort> >(indexPtr, triangleCount, Allocator.None), // "cast" it to an array of Triangles triangleIndicesOut = NativeArrayUnsafeUtility.ConvertExistingDataToNativeArray <Triangle <int> >(faceMesh.indices.GetUnsafePtr(), triangleCount, Allocator.None) }.Schedule(triangleCount, 32); // Wait on all four JobHandle.CombineDependencies( JobHandle.CombineDependencies(vertexJobHandle, normalJobHandle), indexJobHandle, uvJobHandle).Complete(); }
/// <summary> /// Get the mesh texture coordinates of the face that corresponds to a specific <see cref="TrackableId"/>. /// </summary> /// <param name="faceId"><see cref="TrackableId"/> of the face whose mesh we need.</param> /// <param name="uvsOut"> Replaces the content with the list of <see cref="Vector2"/> texture coordinates for this face mesh.</param> /// <returns>True if face mesh UVs were successfully populated.</returns> public virtual bool TryGetFaceMeshUVs(TrackableId faceId, List <Vector2> uvsOut) { if (uvsOut == null) { throw new ArgumentNullException("uvsOut"); } //default implementation clears list to indicate none were returned uvsOut.Clear(); return(false); }
void Update() { if (Input.touchCount == 0) { return; } Touch touch = Input.GetTouch(0); if (Input.touchCount > 0 && EventSystem.current.IsPointerOverGameObject(touch.fingerId)) // UI위에서는 터치가 안되게 하기 { return; } if (touch.phase == TouchPhase.Began) { ray = arCamera.ScreenPointToRay(touch.position); if (Physics.Raycast(ray, out cameraHit, 100.0f)) { if (cameraHit.collider.CompareTag("SPACE")) { ischeckUI = !ischeckUI; //UIObject.SetActive(ischeckUI); Debug.Log(ischeckUI); } } if (ratcastMgr.Raycast(touch.position, hits, TrackableType.PlaneWithinPolygon)) { if (hits[0].trackableId != trackidNow) // 현재 터치한 구간이 새로생긴 경우 { trackidNow = hits[0].trackableId; // 현재 트랙 아이디 저장 foreach (TrackableId ischeckId in spwanedObjs.Keys) // 기존 아이디에 저장될 경우 리턴(한면당 한공간만 생성) { if (ischeckId == trackidNow) { return; } } tempGameObject = Instantiate(placeObject, hits[0].pose.position, hits[0].pose.rotation); Debug.Log("찍은 좌표" + tempGameObject.transform.position); spwanedObjs.Add(trackidNow, tempGameObject); // 터치 아이디 및 오브젝트 추가 //Debug.Log("현재아이디 : " + trackidNow); } else if (hits[0].trackableId == trackidNow) // 현재 터치 구간일 경우 이동 가능 { Debug.Log("찍은 좌표" + hits[0].pose.position); //tempGameObject.transform.Translate(hits[0].pose.position); arSessionOrigin.MakeContentAppearAt(tempGameObject.transform, hits[0].pose.position, tempGameObject.transform.rotation); } } } }
public static ARPlane GetPlane(this ARPlaneManager planeSubsystem, TrackableId trackableId) { planeSubsystem.GetAllPlanes(s_Planes); foreach (var plane in s_Planes) { if (plane.boundedPlane.Id == trackableId) { return(plane); } } return(null); }
/// <summary> /// If in a "pending" state and <see cref="ARTrackable{TSessionRelativeData, TTrackable}.destroyOnRemoval"/> is /// `true`, this method destroys the trackable's <c>GameObject</c>. Otherwise, this method has no effect. /// </summary> /// <remarks> /// <para> /// Trackables are usually removed only when the subsystem reports they /// have been removed during <see cref="Update"/>. /// </para><para> /// This method will immediately remove a trackable only if it was created by /// <see cref="CreateTrackableImmediate(TSessionRelativeData)"/> /// and has not yet been reported as added by the /// <see cref="SubsystemLifecycleManager{TSubsystem,TSubsystemDescriptor,TProvider}.subsystem"/>. /// </para><para> /// This can happen if the trackable is created and removed within the same frame, as the subsystem might never /// have a chance to report its existence. Derived classes should use this /// if they support the concept of manual addition and removal of trackables, as there might not /// be a removal event if the trackable is added and removed quickly. /// </para><para> /// If the trackable is not in a pending state (that is, it has already been reported as "added"), /// then this method does nothing. /// </para> /// <para> /// This method does not invoke <see cref="OnTrackablesChanged(List{TTrackable}, List{TTrackable}, List{TTrackable})"/>, /// so no "removed" notifications will occur until the next call to <see cref="Update"/>. "Removed" notifications will only /// occur if it was previously reported as "added". /// </para> /// </remarks> /// <param name="trackableId">The id of the trackable to destroy.</param> /// <returns><c>True</c> if the trackable is "pending" (that is, not yet reported as "added").</returns> protected bool DestroyPendingTrackable(TrackableId trackableId) { if (m_PendingAdds.TryGetValue(trackableId, out var trackable)) { m_PendingAdds.Remove(trackableId); m_Trackables.Remove(trackableId); DestroyTrackable(trackable); return(true); } return(false); }
TTrackable CreateTrackable(TrackableId trackableId) { var go = CreateGameObject(trackableId); var trackable = go.GetComponent <TTrackable>(); if (trackable == null) { trackable = go.AddComponent <TTrackable>(); } return(trackable); }
public static BoundedPlane GetPlane(this XRPlaneSubsystem planeSubsystem, TrackableId trackableId) { planeSubsystem.GetAllPlanes(s_BoundedPlanes); foreach (var plane in s_BoundedPlanes) { if (plane.Id == trackableId) { return(plane); } } return(new BoundedPlane()); }
GameObject GetOrCreateGameObject(TrackableId meshId) { GameObject go = null; if (!meshIdToGameObjectMap.TryGetValue(meshId, out go)) { go = CreateGameObject(meshId); meshIdToGameObjectMap[meshId] = go; } return(go); }
public override TrackableChanges <UnityEngine.XR.ARSubsystems.XRFace> GetChanges(UnityEngine.XR.ARSubsystems.XRFace defaultFace, Allocator allocator) { var changes = new TrackableChanges <UnityEngine.XR.ARSubsystems.XRFace>(m_AddedFaces.Count, m_UpdatedFaces.Count, m_RemovedFaces.Count, allocator); var numAddedFaces = m_AddedFaces.Count; if (numAddedFaces > 0) { Utils.EnsureCapacity(ref m_ConversionBuffer, numAddedFaces); var i = 0; foreach (var face in m_AddedFaces.Values) { m_ConversionBuffer[i++] = XRFaceFromIMRFace(face); } NativeArray <XRFace> .Copy(m_ConversionBuffer, changes.added.Reinterpret <XRFace>(), numAddedFaces); m_AddedFaces.Clear(); } var numUpdatedFaces = m_UpdatedFaces.Count; if (numUpdatedFaces > 0) { Utils.EnsureCapacity(ref m_ConversionBuffer, numUpdatedFaces); var i = 0; foreach (var face in m_UpdatedFaces.Values) { m_ConversionBuffer[i++] = XRFaceFromIMRFace(face); } NativeArray <XRFace> .Copy(m_ConversionBuffer, changes.updated.Reinterpret <XRFace>(), numUpdatedFaces); m_UpdatedFaces.Clear(); } var numRemovedFaces = m_RemovedFaces.Count; if (numRemovedFaces > 0) { Utils.EnsureCapacity(ref m_IdConversionBuffer, numRemovedFaces); var i = 0; foreach (var id in m_RemovedFaces) { m_IdConversionBuffer[i++] = new TrackableId(id.subId1, id.subId2); } NativeArray <TrackableId> .Copy(m_IdConversionBuffer, changes.removed, numRemovedFaces); m_RemovedFaces.Clear(); } return(changes); }
/// <summary> /// Immediately creates local anchor after detected marker intersects detected plane beneath it. /// Cloud anchor is created afterwards, but it takes some time. When it is finished, scene will be attached to it. /// Called if user clicks on the calibration cube displayed over detected marker. /// </summary> /// <param name="tf"></param> public void CreateAnchor(Transform tf) { #if (UNITY_ANDROID || UNITY_IOS) && AR_ON ARPlane plane = null; UnityEngine.Pose hitPose = new UnityEngine.Pose(); // try to raycast straight down to intersect closest plane List <ARRaycastHit> raycastHits = new List <ARRaycastHit>(); if (ARRaycastManager.Raycast(new Ray(tf.position, Vector3.down), raycastHits, TrackableType.PlaneWithinPolygon)) { hitPose = raycastHits[0].pose; TrackableId hitPlaneId = raycastHits[0].trackableId; plane = ARPlaneManager.GetPlane(hitPlaneId); } // remove all old local anchors, if there are some (in case we are recalibrating) RemoveLocalWorldAnchor(); RemoveCloudWorldAnchor(); // set temporary world anchor //WorldAnchorLocal = ARAnchorManager.AttachAnchor(plane, // new Pose(hitPose.position, Quaternion.FromToRotation(tf.up, plane.normal) * tf.rotation)); //WorldAnchorLocal = ARAnchorManager.AddAnchor(new UnityEngine.Pose(hitPose != new UnityEngine.Pose() ? hitPose.position : tf.position, // plane != null ? Quaternion.FromToRotation(tf.up, plane.normal) * tf.rotation : tf.rotation)); WorldAnchorLocal = ARAnchorManager.AddAnchor(new UnityEngine.Pose(tf.position, plane != null ? Quaternion.FromToRotation(tf.up, plane.normal) * tf.rotation : tf.rotation)); // immediately attach scene to local anchor (after cloud anchor is created, scene will be attached to it) AttachScene(WorldAnchorLocal.gameObject); // Create cloud anchor if (Settings.Instance.UseCloudAnchors) { WorldAnchorCloud = ARAnchorManager.HostCloudAnchor(WorldAnchorLocal); StartCoroutine(HostCloudAnchor()); } else { Calibrated = true; UsingCloudAnchors = false; OnARCalibrated?.Invoke(this, new CalibrationEventArgs(true, WorldAnchorLocal.gameObject)); Notifications.Instance.ShowNotification("Calibration successful", ""); worldAnchorVis = null; ActivateCalibrationElements((bool)MainSettingsMenu.Instance.CalibrationElements.GetValue()); } GameManager.Instance.SceneSetActive(true); ActivateTrackableMarkers(false); #endif }
public static void Update( TrackableId planeId, Pose pose, PlaneAlignment?alignment, PlaneClassification?classification, Vector2 center, Vector2 size) { lock (stateLock) { OnSetPlaneData(planeId, pose, center, size, null, datas[planeId], alignment, classification); } }
bool TryRemoveReferencePointInternal(TrackableId referencePointId, ARReferencePoint referencePoint) { var referencePointSubsystem = ARSubsystemManager.referencePointSubsystem; if (!referencePointSubsystem.TryRemoveReferencePoint(referencePointId)) { return(false); } Destroy(referencePoint.gameObject); m_ReferencePoints.Remove(referencePointId); return(true); }
public static void UnityXRMock_removeAnchor(TrackableId trackableId) { if (s_anchors.ContainsKey(trackableId)) { if (!s_addedAnchors.Remove(trackableId)) { s_removedAnchors[trackableId] = s_anchors[trackableId]; } s_anchors.Remove(trackableId); s_updatedAnchors.Remove(trackableId); } }
public static void UnityXRMock_removePlane(TrackableId planeId) { if (s_planes.ContainsKey(planeId)) { if (!s_addedPlanes.Remove(planeId)) { s_removedPlanes[planeId] = s_planes[planeId]; } s_planes.Remove(planeId); s_updatedPlanes.Remove(planeId); } }
public static void UnityXRMock_removeReferencePoint(TrackableId trackableId) { if (s_refPoints.ContainsKey(trackableId)) { if (!s_addedRefPoints.Remove(trackableId)) { s_removedRefPoints[trackableId] = s_refPoints[trackableId]; } s_refPoints.Remove(trackableId); s_updatedRefPoints.Remove(trackableId); } }
/// <summary> /// Handles the MeshReady event, which tracks and assigns the correct mesh renderer materials. /// </summary> /// <param name="meshId">Id of the mesh that got added / upated.</param> private void HandleOnMeshReady(TrackableId meshId) { if (_spatialMapper.MLSpatialMapper.meshIdToGameObjectMap.ContainsKey(meshId)) { MeshRenderer meshRenderer = _spatialMapper.MLSpatialMapper.meshIdToGameObjectMap[meshId].GetComponent <MeshRenderer>(); // Append the unique MeshRenderer to the dictonary and update the material on that instance. if (!_meshRenderers.ContainsKey(meshId)) { _meshRenderers.Add(meshId, meshRenderer); } UpdateRenderer(meshRenderer); } }
static void GetFaceBlendShapes(XRFaceSubsystem xrFaceSubsystem, TrackableId faceId, Dictionary <string, float> blendshapes) { var arKitFaceSubsystem = (ARKitFaceSubsystem)xrFaceSubsystem; blendshapes.Clear(); using (var blendShapeCoefficients = arKitFaceSubsystem.GetBlendShapeCoefficients(faceId, Allocator.Temp)) { foreach (var featureCoefficient in blendShapeCoefficients) { blendshapes[featureCoefficient.blendShapeLocation.ToString()] = featureCoefficient.coefficient; } } }
private void UpdateNavMesh(TrackableId id) { if (verbose) { Debug.Log("Update Mesh " + id); } NavMeshGraph graph; if (idToNav.TryGetValue(id, out graph)) { QueueForUpdate(graph); } }
public override TrackableChanges <BoundedPlane> GetChanges(BoundedPlane defaultPlane, Allocator allocator) { var changes = new TrackableChanges <BoundedPlane>(m_AddedPlanes.Count, m_UpdatedPlanes.Count, m_RemovedPlanes.Count, allocator); var numAddedPlanes = m_AddedPlanes.Count; if (numAddedPlanes > 0) { Utils.EnsureCapacity(ref m_ConversionBuffer, numAddedPlanes); var i = 0; foreach (var plane in m_AddedPlanes.Values) { m_ConversionBuffer[i++] = BoundedPlaneFromMRPlane(plane); } NativeArray <BoundedPlane> .Copy(m_ConversionBuffer, changes.added, numAddedPlanes); m_AddedPlanes.Clear(); } var numUpdatedPlanes = m_UpdatedPlanes.Count; if (numUpdatedPlanes > 0) { Utils.EnsureCapacity(ref m_ConversionBuffer, numUpdatedPlanes); var i = 0; foreach (var plane in m_UpdatedPlanes.Values) { m_ConversionBuffer[i++] = BoundedPlaneFromMRPlane(plane); } NativeArray <BoundedPlane> .Copy(m_ConversionBuffer, changes.updated, numUpdatedPlanes); m_UpdatedPlanes.Clear(); } var numRemovedPlanes = m_RemovedPlanes.Count; if (numRemovedPlanes > 0) { Utils.EnsureCapacity(ref m_IdConversionBuffer, numRemovedPlanes); var i = 0; foreach (var id in m_RemovedPlanes) { m_IdConversionBuffer[i++] = new TrackableId(id.subId1, id.subId2); } NativeArray <TrackableId> .Copy(m_IdConversionBuffer, changes.removed, numRemovedPlanes); m_RemovedPlanes.Clear(); } return(changes); }
/// <summary> /// 'Refresh' a single mesh. This forces the mesh to be regenerated with the current settings. /// </summary> /// <param name="meshId">The <c>TrackableId</c> of the mesh to regenerate.</param> public void RefreshMesh(TrackableId meshId) { if (m_MeshesBeingGenerated.ContainsKey(meshId)) { return; } m_MeshesNeedingGeneration[meshId] = new MeshInfo { MeshId = meshId, ChangeState = MeshChangeState.Updated, PriorityHint = Time.frameCount }; }
ARReferencePoint CreateReferencePointComponent(TrackableId referencePointId, Pose pose) { if (referencePointId == TrackableId.InvalidId) { return(null); } // Get the data back of the XRReferencePointSubsystem ReferencePoint referencePointData; var referencePointExists = ARSubsystemManager.referencePointSubsystem.TryGetReferencePoint( referencePointId, out referencePointData); // It's possible the native code has updated its internal state to include the reference // point we just created, so manufacture some data in that case. if (!referencePointExists) { referencePointData = CreateReferencePoint(referencePointId, TrackingState.Unknown, pose); } // Create a new GameObject for this point var parentTransform = m_SessionOrigin.trackablesParent; GameObject go; if (referencePointPrefab != null) { go = Instantiate(referencePointPrefab, parentTransform); } else { go = new GameObject(); go.transform.SetParent(parentTransform, false); } go.name = string.Format("ReferencePoint {0}", referencePointId); go.layer = gameObject.layer; // Make sure it has an ARReferencePoint component. var referencePoint = go.GetComponent <ARReferencePoint>(); if (referencePoint == null) { referencePoint = go.AddComponent <ARReferencePoint>(); } m_ReferencePoints.Add(referencePointId, referencePoint); referencePoint.sessionRelativeData = referencePointData; return(referencePoint); }
public static void Add(TrackableId trackableId, Pose pose, TrackingState trackingState) { lock (stateLock) { var tmp = new DepthInfo() { trackableId = trackableId, pose = pose, trackingState = trackingState }; all[trackableId] = tmp; added.Add(tmp); } }
public IEnumerator RemovingAnchorReturnsMarkedAnchor() { TrackableId rpId = defaultId; yield return(AddAndCheckAnchor((tid) => { Assert.AreNotEqual(rpId, tid); rpId = tid; })); Assert.AreNotEqual(defaultId, rpId); yield return(RemoveAndCheckAnchor(rpId, (tid) => { Assert.AreEqual(rpId, tid); })); }