/// <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);
}));
}