// Deactivates the given dataset.
// This can only be done when the tracker is not running.
public override bool DeactivateDataSet(DataSet dataSet)
{
if (dataSet == null)
{
Debug.LogError("Dataset is null.");
return(false);
}
DataSetImpl dataSetImpl = (DataSetImpl)dataSet;
if (QCARWrapper.Instance.ImageTrackerDeactivateDataSet(dataSetImpl.DataSetPtr) == 0)
{
Debug.LogError("Could not deactivate dataset.");
return(false);
}
StateManagerImpl stateManager = (StateManagerImpl)TrackerManager.Instance.GetStateManager();
// Deactivate all Trackables.
foreach (Trackable trackable in dataSet.GetTrackables())
{
stateManager.EnableTrackableBehavioursForTrackable(trackable, false);
}
mActiveDataSets.Remove(dataSetImpl);
return(true);
}
/// <summary>
/// Enable this search result for tracking
///
/// Creates an ImageTarget for local detection and tracking of this target.
/// If the given game object has no ImageTargetBehaviour, a new one will be created.
/// Note that this call may result in an earlier ImageTarget that was enabled for
/// tracking to be destroyed, including its ImageTargetBehaviour.
/// Thus it is not advised to hold a pointer to an
/// ealier created ImageTarget after calling enableTracking again. Returns
/// NULL if the target failed to be enabled for tracking.
/// </summary>
public override ImageTargetBehaviour EnableTracking(TargetSearchResult result, GameObject gameObject)
{
// create a new trackable in native
IntPtr imageTargetPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(ImageTargetData)));
int newTrackableCount = QCARWrapper.Instance.TargetFinderEnableTracking(result.TargetSearchResultPtr, imageTargetPtr);
ImageTargetData imageTargetData = (ImageTargetData)
Marshal.PtrToStructure(imageTargetPtr, typeof(ImageTargetData));
Marshal.FreeHGlobal(imageTargetPtr);
StateManagerImpl stateManager = (StateManagerImpl)TrackerManager.Instance.GetStateManager();
// if successful, create a new trackable here and add it to internal collection
ImageTargetBehaviour imageTargetBehaviour = null;
if (imageTargetData.id == -1)
{
Debug.LogError("TargetSearchResult " + result.TargetName + " could not be enabled for tracking.");
}
else
{
ImageTarget newImageTarget = new CloudRecoImageTargetImpl(result.TargetName, imageTargetData.id, imageTargetData.size);
// Add newly created Image Target to dictionary.
mImageTargets[imageTargetData.id] = newImageTarget;
// Find or create ImageTargetBehaviour for this ImageTarget:
imageTargetBehaviour = stateManager.FindOrCreateImageTargetBehaviourForTrackable(newImageTarget, gameObject);
}
// get a list of currently existing trackables
IntPtr imageTargetIdArrayPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(int)) * newTrackableCount);
QCARWrapper.Instance.TargetFinderGetImageTargets(imageTargetIdArrayPtr, newTrackableCount);
List <int> targetIds = new List <int>();
for (int i = 0; i < newTrackableCount; i++)
{
IntPtr targetIdPtr = new IntPtr(imageTargetIdArrayPtr.ToInt32() + i * Marshal.SizeOf(typeof(int)));
int targetID = Marshal.ReadInt32(targetIdPtr);
targetIds.Add(targetID);
}
Marshal.FreeHGlobal(imageTargetIdArrayPtr);
// delete those targets that no longer exist
foreach (ImageTarget imageTarget in mImageTargets.Values.ToArray())
{
if (!targetIds.Contains(imageTarget.ID))
{
stateManager.DestroyTrackableBehavioursForTrackable(imageTarget);
mImageTargets.Remove(imageTarget.ID);
}
}
return(imageTargetBehaviour);
}
// Deinitialize QCAR and trackers when QCARBehaviour is destroyed.
void OnDestroy()
{
// clear all trackable results in the StateManager
StateManagerImpl stateManager = (StateManagerImpl)TrackerManager.Instance.GetStateManager();
stateManager.ClearTrackableBehaviours();
// Destroy all the datasets
ImageTracker imageTracker = (ImageTracker)TrackerManager.Instance.GetTracker(Tracker.Type.IMAGE_TRACKER);
if (imageTracker != null)
{
imageTracker.DestroyAllDataSets(false);
imageTracker.Stop();
}
// Destroy all the markers
MarkerTracker markerTracker = (MarkerTracker)TrackerManager.Instance.GetTracker(Tracker.Type.MARKER_TRACKER);
if (markerTracker != null)
{
markerTracker.DestroyAllMarkers(false);
markerTracker.Stop();
}
TextTracker textTracker = (TextTracker)TrackerManager.Instance.GetTracker(Tracker.Type.TEXT_TRACKER);
if (textTracker != null)
{
textTracker.Stop();
}
// Deinit the QCARManager
QCARManager.Instance.Deinit();
// Deinit the trackers
if (TrackerManager.Instance.GetTracker(Tracker.Type.MARKER_TRACKER) != null)
{
TrackerManager.Instance.DeinitTracker(Tracker.Type.MARKER_TRACKER);
}
if (TrackerManager.Instance.GetTracker(Tracker.Type.IMAGE_TRACKER) != null)
{
TrackerManager.Instance.DeinitTracker(Tracker.Type.IMAGE_TRACKER);
}
if (TrackerManager.Instance.GetTracker(Tracker.Type.TEXT_TRACKER) != null)
{
TrackerManager.Instance.DeinitTracker(Tracker.Type.TEXT_TRACKER);
}
if (QCARRuntimeUtilities.IsPlayMode())
{
// deinit explicitly if running in the emulator
QCARWrapper.Instance.QcarDeinit();
}
}
public override void Stop()
{
QCARWrapper.Instance.MarkerTrackerStop();
StateManagerImpl stateManager = (StateManagerImpl)TrackerManager.Instance.GetStateManager();
foreach (Marker marker in this.mMarkerDict.Values)
{
stateManager.SetTrackableBehavioursForTrackableToNotFound(marker);
}
}
public override void Stop()
{
QCARWrapper.Instance.ImageTrackerStop();
StateManagerImpl stateManager = (StateManagerImpl)TrackerManager.Instance.GetStateManager();
foreach (DataSetImpl impl2 in this.mActiveDataSets)
{
foreach (Trackable trackable in impl2.GetTrackables())
{
stateManager.SetTrackableBehavioursForTrackableToNotFound(trackable);
}
}
}
// Stops the tracker.
// The tracker needs to be stopped before Trackables can be modified.
public override void Stop()
{
QCARWrapper.Instance.ImageTrackerStop();
StateManagerImpl stateManager = (StateManagerImpl)TrackerManager.Instance.GetStateManager();
// If a dataset is active, than mark all trackables as not found:
foreach (DataSetImpl activeDataSet in mActiveDataSets)
{
foreach (Trackable trackable in activeDataSet.GetTrackables())
{
stateManager.SetTrackableBehavioursForTrackableToNotFound(trackable);
}
}
}
public override MarkerAbstractBehaviour CreateMarker(int markerID, string trackableName, float size)
{
int id = this.RegisterMarker(markerID, trackableName, size);
if (id == -1)
{
Debug.LogError("Could not create marker with id " + markerID + ".");
return(null);
}
Marker trackable = new MarkerImpl(trackableName, id, size, markerID);
this.mMarkerDict[id] = trackable;
StateManagerImpl stateManager = (StateManagerImpl)TrackerManager.Instance.GetStateManager();
return(stateManager.CreateNewMarkerBehaviourForMarker(trackable, trackableName));
}
/// <summary>
/// Clears all targets enabled for tracking
///
/// Destroys all ImageTargets that have been created via EnableTracking().
/// </summary>
public override void ClearTrackables(bool destroyGameObjects = true)
{
// call native function
QCARWrapper.Instance.TargetFinderClearTrackables();
// destroy ImageTargetBehaviours in StateManager
StateManagerImpl stateManager = (StateManagerImpl)TrackerManager.Instance.GetStateManager();
foreach (ImageTarget imageTarget in mImageTargets.Values)
{
stateManager.DestroyTrackableBehavioursForTrackable(imageTarget, destroyGameObjects);
}
// clear internal collection
mImageTargets.Clear();
}
/// <summary>
/// This method must not be called while the dataset is active or it will return false.
/// </summary>
public override bool Destroy(Trackable trackable, bool destroyGameObject)
{
if (QCARWrapper.Instance.DataSetDestroyTrackable(mDataSetPtr, trackable.ID) == 0)
{
Debug.LogError("Could not destroy trackable with id " + trackable.ID + ".");
return(false);
}
mTrackablesDict.Remove(trackable.ID);
if (destroyGameObject)
{
StateManagerImpl stateManager = (StateManagerImpl)TrackerManager.Instance.GetStateManager();
stateManager.DestroyTrackableBehavioursForTrackable(trackable);
}
return(true);
}
// Destroys the marker associated with the given MarkerBehaviour
// at native code.
public override bool DestroyMarker(Marker marker, bool destroyGameObject)
{
if (QCARWrapper.Instance.MarkerTrackerDestroyMarker(marker.ID) == 0)
{
Debug.LogError("Could not destroy marker with id " + marker.MarkerID + ".");
return(false);
}
mMarkerDict.Remove(marker.ID);
if (destroyGameObject)
{
StateManagerImpl stateManager = (StateManagerImpl)TrackerManager.Instance.GetStateManager();
stateManager.DestroyTrackableBehavioursForTrackable(marker);
}
return(true);
}
public override ImageTargetAbstractBehaviour EnableTracking(TargetFinder.TargetSearchResult result, GameObject gameObject)
{
IntPtr trackableData = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(ImageTargetData)));
int trackableIdArrayLength = QCARWrapper.Instance.TargetFinderEnableTracking(result.TargetSearchResultPtr, trackableData);
ImageTargetData data = (ImageTargetData)Marshal.PtrToStructure(trackableData, typeof(ImageTargetData));
Marshal.FreeHGlobal(trackableData);
StateManagerImpl stateManager = (StateManagerImpl)TrackerManager.Instance.GetStateManager();
ImageTargetAbstractBehaviour behaviour = null;
if (data.id == -1)
{
Debug.LogError("TargetSearchResult " + result.TargetName + " could not be enabled for tracking.");
}
else
{
ImageTarget trackable = new CloudRecoImageTargetImpl(result.TargetName, data.id, data.size);
this.mImageTargets[data.id] = trackable;
behaviour = stateManager.FindOrCreateImageTargetBehaviourForTrackable(trackable, gameObject);
}
IntPtr trackableIdArray = Marshal.AllocHGlobal((int)(Marshal.SizeOf(typeof(int)) * trackableIdArrayLength));
QCARWrapper.Instance.TargetFinderGetImageTargets(trackableIdArray, trackableIdArrayLength);
List <int> list = new List <int>();
for (int i = 0; i < trackableIdArrayLength; i++)
{
IntPtr ptr = new IntPtr(trackableIdArray.ToInt32() + (i * Marshal.SizeOf(typeof(int))));
int item = Marshal.ReadInt32(ptr);
list.Add(item);
}
Marshal.FreeHGlobal(trackableIdArray);
foreach (ImageTarget target2 in this.mImageTargets.Values.ToArray <ImageTarget>())
{
if (!list.Contains(target2.ID))
{
stateManager.DestroyTrackableBehavioursForTrackable(target2, true);
this.mImageTargets.Remove(target2.ID);
}
}
return(behaviour);
}
public override DataSetTrackableBehaviour CreateTrackable(TrackableSource trackableSource, GameObject gameObject)
{
TrackableSourceImpl impl = (TrackableSourceImpl)trackableSource;
int capacity = 0x80;
StringBuilder trackableName = new StringBuilder(capacity);
IntPtr trackableData = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(SimpleTargetData)));
int num2 = QCARWrapper.Instance.DataSetCreateTrackable(this.mDataSetPtr, impl.TrackableSourcePtr, trackableName, capacity, trackableData);
SimpleTargetData data = (SimpleTargetData)Marshal.PtrToStructure(trackableData, typeof(SimpleTargetData));
Marshal.FreeHGlobal(trackableData);
if (num2 == TypeMapping.GetTypeID(typeof(ImageTarget)))
{
ImageTarget trackable = new ImageTargetImpl(trackableName.ToString(), data.id, ImageTargetType.USER_DEFINED, this);
this.mTrackablesDict[data.id] = trackable;
Debug.Log(string.Format("Trackable created: {0}, {1}", num2, trackableName));
StateManagerImpl stateManager = (StateManagerImpl)TrackerManager.Instance.GetStateManager();
return(stateManager.FindOrCreateImageTargetBehaviourForTrackable(trackable, gameObject, this));
}
Debug.LogError("DataSet.CreateTrackable returned unknown or incompatible trackable type!");
return(null);
}
// Adds a single trackable from a source and a given gameobject to this dataset
public override DataSetTrackableBehaviour CreateTrackable(TrackableSource trackableSource, GameObject gameObject)
{
// create a trackable in native from the trackable source handle:
TrackableSourceImpl trackableSourceImpl = (TrackableSourceImpl)trackableSource;
// QCAR support names up to 64 characters in length, but here we allocate
// a slightly larger buffer:
int nameLength = 128;
System.Text.StringBuilder trackableName = new System.Text.StringBuilder(nameLength);
IntPtr targetDataPtr =
Marshal.AllocHGlobal(Marshal.SizeOf(typeof(SimpleTargetData)));
TrackableType trackableType = (TrackableType)QCARWrapper.Instance.DataSetCreateTrackable(mDataSetPtr, trackableSourceImpl.TrackableSourcePtr, trackableName, nameLength, targetDataPtr);
SimpleTargetData targetData = (SimpleTargetData)
Marshal.PtrToStructure(targetDataPtr, typeof(SimpleTargetData));
Marshal.FreeHGlobal(targetDataPtr);
// currently only supported for ImageTargets:
if (trackableType == TrackableType.IMAGE_TARGET)
{
ImageTarget newImageTarget = new ImageTargetImpl(trackableName.ToString(), targetData.id, ImageTargetType.USER_DEFINED, this);
// Add newly created Image Target to dictionary.
mTrackablesDict[targetData.id] = newImageTarget;
Debug.Log(string.Format("Trackable created: {0}, {1}", trackableType, trackableName));
// Find or create ImageTargetBehaviour for this ImageTarget:
StateManagerImpl stateManager = (StateManagerImpl)TrackerManager.Instance.GetStateManager();
return(stateManager.FindOrCreateImageTargetBehaviourForTrackable(newImageTarget, gameObject, this));
}
else
{
Debug.LogError("DataSet.CreateTrackable returned unknown or incompatible trackable type!");
return(null);
}
}
// Creates a marker with the given id, name, and size.
// Registers the marker at native code.
// Returns a MarkerBehaviour object to receive updates.
public override MarkerBehaviour CreateMarker(int markerID, String trackableName, float size)
{
int trackableID = RegisterMarker(markerID, trackableName, size);
if (trackableID == -1)
{
Debug.LogError("Could not create marker with id " + markerID + ".");
return(null);
}
// create a new marker object:
Marker marker = new MarkerImpl(trackableName, trackableID, size, markerID);
// Add newly created Marker to dictionary.
mMarkerDict[trackableID] = marker;
// let the state manager create a new Marker Behaviour and return it:
StateManagerImpl stateManager = (StateManagerImpl)TrackerManager.Instance.GetStateManager();
MarkerBehaviour newMB = stateManager.CreateNewMarkerBehaviourForMarker(marker, trackableName);
return(newMB);
}
// Loads data set from the given path.
// Storage type is used to correctly interpret the given path.
public override bool Load(String path, StorageType storageType)
{
if (mDataSetPtr == IntPtr.Zero)
{
Debug.LogError("Called Load without a data set object");
return(false);
}
// copied on purpose because original value is needed later on
String actualPath = path;
if (storageType == StorageType.STORAGE_APPRESOURCE && QCARRuntimeUtilities.IsPlayMode())
{
actualPath = "Assets/StreamingAssets/" + actualPath;
}
if (QCARWrapper.Instance.DataSetLoad(actualPath, (int)storageType, mDataSetPtr) == 0)
{
Debug.LogError("Did not load: " + path);
return(false);
}
// Set path and storage type to associate data sets with Trackables.
mPath = path;
mStorageType = storageType;
// Create Trackabls in this dataset.
CreateImageTargets();
CreateMultiTargets();
CreateCylinderTargets();
// associate existing TrackableBehaviours with the trackables in this dataset and create missing behaviours:
StateManagerImpl stateManager = (StateManagerImpl)TrackerManager.Instance.GetStateManager();
stateManager.AssociateTrackableBehavioursForDataSet(this);
return(true);
}
public override bool ActivateDataSet(DataSet dataSet)
{
if (dataSet == null)
{
Debug.LogError("Dataset is null.");
return(false);
}
DataSetImpl item = (DataSetImpl)dataSet;
if (QCARWrapper.Instance.ImageTrackerActivateDataSet(item.DataSetPtr) == 0)
{
Debug.LogError("Could not activate dataset.");
return(false);
}
StateManagerImpl stateManager = (StateManagerImpl)TrackerManager.Instance.GetStateManager();
foreach (Trackable trackable in item.GetTrackables())
{
stateManager.EnableTrackableBehavioursForTrackable(trackable, true);
}
this.mActiveDataSets.Add(item);
return(true);
}
// Unmarshal and process the tracking data
private void UpdateTrackers(FrameState frameState)
{
// Unmarshal the trackable data
// Take our array of unmanaged data from native and create an array of
// TrackableResultData structures to work with (one per trackable, regardless
// of whether or not that trackable is visible this frame).
for (int i = 0; i < frameState.numTrackableResults; i++)
{
IntPtr trackablePtr = new IntPtr(frameState.trackableDataArray.ToInt32() + i *
Marshal.SizeOf(typeof(TrackableResultData)));
TrackableResultData trackableResultData = (TrackableResultData)
Marshal.PtrToStructure(trackablePtr, typeof(TrackableResultData));
mTrackableResultDataArray[i] = trackableResultData;
}
// Add newly found Trackables to the queue, remove lost ones
// We keep track of the order in which Trackables become visible for the
// AUTO World Center mode. This keeps the camera from jumping around in the
// scene too much.
foreach (TrackableResultData trackableData in mTrackableResultDataArray)
{
// We found a trackable (or set of Trackables) that match this id
if ((trackableData.status == TrackableBehaviour.Status.DETECTED ||
trackableData.status ==
TrackableBehaviour.Status.TRACKED))
{
if (!mTrackableFoundQueue.Contains(trackableData.id))
{
// The trackable just became visible, add it to the queue
mTrackableFoundQueue.AddLast(trackableData.id);
}
}
else
{
if (mTrackableFoundQueue.Contains(trackableData.id))
{
// The trackable just disappeared, remove it from the queue
mTrackableFoundQueue.Remove(trackableData.id);
}
}
}
// now remove those from the TrackableFoundQueue that were not in this frame's results:
List <int> trackableFoundQueueCopy = new List <int>(mTrackableFoundQueue);
foreach (int id in trackableFoundQueueCopy)
{
// check if the trackable is in this frame's results:
if (Array.Exists(mTrackableResultDataArray, tr => tr.id == id))
{
break;
}
// not in the results, remove it from the queue
mTrackableFoundQueue.Remove(id);
}
StateManagerImpl stateManager = (StateManagerImpl)
TrackerManager.Instance.GetStateManager();
// The "scene origin" is only used in world center mode auto or user.
int originTrackableID = -1;
if (mWorldCenterMode == QCARBehaviour.WorldCenterMode.SPECIFIC_TARGET &&
mWorldCenter != null)
{
originTrackableID = mWorldCenter.Trackable.ID;
}
else if (mWorldCenterMode == QCARBehaviour.WorldCenterMode.FIRST_TARGET)
{
stateManager.RemoveDisabledTrackablesFromQueue(ref mTrackableFoundQueue);
if (mTrackableFoundQueue.Count > 0)
{
originTrackableID = mTrackableFoundQueue.First.Value;
}
}
// Unmarshal words and word results
UpdateWordTrackables(frameState);
// Update the Camera pose before Trackable poses are updated.
stateManager.UpdateCameraPose(mARCamera, mTrackableResultDataArray, originTrackableID);
// Update the Trackable poses.
stateManager.UpdateTrackablePoses(mARCamera, mTrackableResultDataArray, originTrackableID, frameState.frameIndex);
// Update Word Trackables
stateManager.UpdateWords(mARCamera, mWordDataArray, mWordResultDataArray);
// Update Virtual Button states.
stateManager.UpdateVirtualButtons(frameState.numVirtualButtonResults, frameState.vbDataArray);
}
// Starts up the QCAR extension with the properties that were set in the
// Unity inspector.
void Start()
{
// keeps the ARCamera object alive across scenes:
if (KeepAliveBehaviour.Instance != null && KeepAliveBehaviour.Instance.KeepARCameraAlive)
{
DontDestroyOnLoad(gameObject);
}
Debug.Log("QCARWrapper.Start");
// First we check if QCAR initialized correctly.
if (QCARUnity.CheckInitializationError() != QCARUnity.InitError.INIT_SUCCESS)
{
mIsInitialized = false;
return;
}
// Initialize the trackers if they haven't already been initialized.
if (TrackerManager.Instance.GetTracker(Tracker.Type.MARKER_TRACKER) == null)
{
TrackerManager.Instance.InitTracker(Tracker.Type.MARKER_TRACKER);
}
if (TrackerManager.Instance.GetTracker(Tracker.Type.IMAGE_TRACKER) == null)
{
TrackerManager.Instance.InitTracker(Tracker.Type.IMAGE_TRACKER);
}
// Cache the camera start values
mCachedDrawVideoBackground = QCARManager.Instance.DrawVideoBackground;
mCachedCameraClearFlags = this.camera.clearFlags;
mCachedCameraBackgroundColor = this.camera.backgroundColor;
// keep the device's screen turned on and bright.
Screen.sleepTimeout = SleepTimeout.NeverSleep;
// Reset the camera clear flags and create a simple material
ResetCameraClearFlags();
mClearMaterial = new Material(Shader.Find("Diffuse"));
// Set QCAR hints from the Inspector options
QCARUnity.SetHint(QCARUnity.QCARHint.HINT_MAX_SIMULTANEOUS_IMAGE_TARGETS,
MaxSimultaneousImageTargets);
// Set the Unity version for internal use
QCARUnityImpl.SetUnityVersion(Application.persistentDataPath, true);
// register markers in QCAR:
StateManagerImpl stateManager = (StateManagerImpl)TrackerManager.Instance.GetStateManager();
stateManager.AssociateMarkerBehaviours();
// Start the camera and tracker
StartQCAR();
// Initialize the QCARManager
QCARManager.Instance.WorldCenterMode = mWorldCenterMode;
QCARManager.Instance.WorldCenter = mWorldCenter;
QCARManager.Instance.ARCamera = camera;
QCARManager.Instance.Init();
// Initialize local variables
mIsInitialized = true;
// Let the trackable event handlers know that QCAR has been initialized
foreach (ITrackerEventHandler handler in mTrackerEventHandlers)
{
handler.OnInitialized();
}
mHasStartedOnce = true;
}
private void OnLevelWasLoaded()
{
if (this.mKeepARCameraAlive)
{
List <TrackableBehaviour> list;
StateManagerImpl stateManager = (StateManagerImpl)TrackerManager.Instance.GetStateManager();
if (this.mKeepTrackableBehavioursAlive)
{
list = stateManager.GetTrackableBehaviours().ToList <TrackableBehaviour>();
foreach (WordAbstractBehaviour behaviour in stateManager.GetWordManager().GetTrackableBehaviours())
{
list.Add(behaviour);
}
}
else
{
list = new List <TrackableBehaviour>();
}
foreach (ILoadLevelEventHandler handler in this.mHandlers)
{
handler.OnLevelLoaded(list);
}
TrackableBehaviour[] behaviourArray = (TrackableBehaviour[])UnityEngine.Object.FindObjectsOfType(typeof(TrackableBehaviour));
stateManager.RemoveDestroyedTrackables();
stateManager.AssociateMarkerBehaviours();
ImageTracker tracker = TrackerManager.Instance.GetTracker <ImageTracker>();
if (tracker != null)
{
IEnumerable <DataSet> dataSets = tracker.GetDataSets();
List <DataSet> list2 = tracker.GetActiveDataSets().ToList <DataSet>();
foreach (DataSet set in dataSets)
{
if (list2.Contains(set))
{
tracker.DeactivateDataSet(set);
}
stateManager.AssociateTrackableBehavioursForDataSet(set);
if (list2.Contains(set))
{
tracker.ActivateDataSet(set);
}
}
}
bool flag = false;
TextRecoAbstractBehaviour behaviour2 = (TextRecoAbstractBehaviour)UnityEngine.Object.FindObjectOfType(typeof(TextRecoAbstractBehaviour));
if (behaviour2 != null)
{
if (!behaviour2.IsInitialized)
{
flag = true;
}
else
{
WordManagerImpl wordManager = (WordManagerImpl)stateManager.GetWordManager();
wordManager.RemoveDestroyedTrackables();
wordManager.InitializeWordBehaviourTemplates();
}
}
List <TrackableBehaviour> disabledTrackables = new List <TrackableBehaviour>();
IEnumerable <TrackableBehaviour> trackableBehaviours = stateManager.GetTrackableBehaviours();
IEnumerable <WordAbstractBehaviour> source = stateManager.GetWordManager().GetTrackableBehaviours();
foreach (TrackableBehaviour behaviour3 in behaviourArray)
{
if (behaviour3 is WordAbstractBehaviour)
{
if (!flag && !source.Contains <WordAbstractBehaviour>((behaviour3 as WordAbstractBehaviour)))
{
behaviour3.gameObject.SetActive(false);
disabledTrackables.Add(behaviour3);
}
}
else if ((!(behaviour3 is ImageTargetAbstractBehaviour) || (((IEditorImageTargetBehaviour)behaviour3).ImageTargetType == ImageTargetType.PREDEFINED)) && !trackableBehaviours.Contains <TrackableBehaviour>(behaviour3))
{
behaviour3.gameObject.SetActive(false);
disabledTrackables.Add(behaviour3);
}
}
foreach (ILoadLevelEventHandler handler2 in this.mHandlers)
{
handler2.OnDuplicateTrackablesDisabled(disabledTrackables);
}
}
}
