/// <summary>
/// Gets Trackables ARCore has detected.
/// </summary>
/// <param name="trackables">A reference to a list of detected planes that will be filled by the method call.</param>
/// <param name="filter">A filter on the type of data to return.</param>
public static List <EazyARDetectedPlane> GetTrackablePlanes(TrackableQueryFilter filter = TrackableQueryFilter.All)
{
List <EazyARDetectedPlane> planes = new List <EazyARDetectedPlane>();
if (EazyARCoreInterface.isSimulated && (!simulatedPlaneDetected || filter == TrackableQueryFilter.All))
{
// simulated horizontal plane
planes.Add(new EazyARDetectedPlane());
// simulated vertical plane
Quaternion rot = new Quaternion();
rot.eulerAngles = new Vector3(0, 90, -90);
Pose pose = new Pose(Vector3.zero, rot);
planes.Add(new EazyARDetectedPlane(pose));
simulatedPlaneDetected = true;
}
else if (!EazyARCoreInterface.isSimulated)
{
List <DetectedPlane> trackedPlanes = new List <DetectedPlane>();
Session.GetTrackables <DetectedPlane>(trackedPlanes, filter);
foreach (DetectedPlane plane in trackedPlanes)
{
planes.Add(new EazyARDetectedPlane(plane));
}
}
return(planes);
}
/// <summary>
/// Gets planes ARCore has tracked.
/// </summary>
/// <param name="planes">A reference to a list of TrackedPlane that will be filled by the method call.</param>
/// <param name="filter">A filter on the type of data to return.</param>
public static void GetPlanes(List <TrackedPlane> planes, TrackableQueryFilter filter = TrackableQueryFilter.All)
{
if (s_FrameManager == null)
{
planes.Clear();
return;
}
s_FrameManager.GetTrackables <TrackedPlane>(planes, filter);
}
public static void GetTrackables <T>(List <T> trackables, TrackableQueryFilter filter = TrackableQueryFilter.All) where T : Trackable
{
trackables.Clear();
var nativeSession = LifecycleManager.Instance.NativeSession;
if (nativeSession == null)
{
return;
}
nativeSession.GetTrackables <T>(trackables, filter);
}
public void GetTrackables <T>(
List <T> trackables, TrackableQueryFilter filter) where T : Trackable
{
if (m_LastUpdateFrame < Time.frameCount)
{
// Get trackables updated this frame.
m_NativeSession.FrameApi.GetUpdatedTrackables(m_UpdatedTrackables);
// Get all the trackables in the session.
m_NativeSession.SessionApi.GetAllTrackables(m_AllTrackables);
// Find trackables that are not in the hashset (new).
m_NewTrackables.Clear();
for (int i = 0; i < m_AllTrackables.Count; i++)
{
Trackable trackable = m_AllTrackables[i];
if (!m_OldTrackables.Contains(trackable))
{
m_NewTrackables.Add(trackable);
m_OldTrackables.Add(trackable);
}
}
m_LastUpdateFrame = Time.frameCount;
}
trackables.Clear();
if (filter == TrackableQueryFilter.All)
{
for (int i = 0; i < m_AllTrackables.Count; i++)
{
_SafeAdd <T>(m_AllTrackables[i], trackables);
}
}
else if (filter == TrackableQueryFilter.New)
{
for (int i = 0; i < m_NewTrackables.Count; i++)
{
_SafeAdd <T>(m_NewTrackables[i], trackables);
}
}
else if (filter == TrackableQueryFilter.Updated)
{
for (int i = 0; i < m_UpdatedTrackables.Count; i++)
{
_SafeAdd <T>(m_UpdatedTrackables[i], trackables);
}
}
}
private void InstantiatePlanes(TrackableQueryFilter filter)
{
List <TrackedPlane> planes = new List <TrackedPlane>();
Frame.GetPlanes(planes, filter);
for (int i = 0; i < planes.Count; i++)
{
// Instantiate a plane visualization prefab and set it to track the new plane. The transform is set to
// the origin with an identity rotation since the mesh for our prefab is updated in Unity World
// coordinates.
GameObject planeObject = Instantiate(TrackedPlanePrefab, planes[i].Position, Quaternion.identity, transform);
planeObject.GetComponent <TrackedPlaneVisualizer>().Initialize(planes[i]);
allPlaneObjects.Add(planeObject);
}
}
public void GetTrackables <T>(List <T> trackables, TrackableQueryFilter filter) where T : Trackable
{
m_TrackableManager.GetTrackables <T>(trackables, filter);
}
