public void OnNewTrackableSource(TrackableSource trackableSource)
{
if (trackable != null)
{
return;
} // 이미 있으면 새로 생성하지 않는다.
// deactivates the dataset first
mImageTracker.DeactivateDataSet(mBuiltDataSet);
// 타겟 템플릿을 복제해 실제 추적할 타겟을 만든다.
ImageTargetBehaviour targetTemplate = GetTargetTemplate(lastTargetType);
if (targetTemplate == null)
{
return;
}
GameObject objCopy = Instantiate(targetTemplate.gameObject) as GameObject;
ImageTargetBehaviour imageTargetCopy = objCopy.GetComponent <ImageTargetBehaviour>();
imageTargetCopy.gameObject.name = targetTemplate.TrackableName + "_Created";
// 추적 정보를 생성하고, 생성된 정보를 유지
DataSetTrackableBehaviour created = mBuiltDataSet.CreateTrackable(trackableSource, imageTargetCopy.gameObject);
trackable = created.Trackable;
objTarget = imageTargetCopy.gameObject;
// activate the dataset again
mImageTracker.ActivateDataSet(mBuiltDataSet);
}
/// <summary>
/// Takes a given GameObject to add a new ImageTargetBehaviour to. This new Behaviour is associated with the given ImageTarget
/// </summary>
public ImageTargetBehaviour FindOrCreateImageTargetBehaviourForTrackable(ImageTarget trackable, GameObject gameObject, DataSet dataSet)
{
DataSetTrackableBehaviour trackableBehaviour = gameObject.GetComponent <DataSetTrackableBehaviour>();
// add an ImageTargetBehaviour if none is attached yet
if (trackableBehaviour == null)
{
trackableBehaviour = gameObject.AddComponent <ImageTargetBehaviour>();
((IEditorTrackableBehaviour)trackableBehaviour).SetInitializedInEditor(true);
}
// configure the new ImageTargetBehaviour instance:
if (!(trackableBehaviour is ImageTargetBehaviour))
{
Debug.LogError(
string.Format("DataSet.CreateTrackable: Trackable of type ImageTarget was created, but behaviour of type {0} was provided!",
trackableBehaviour.GetType()));
return(null);
}
IEditorImageTargetBehaviour editorImgTargetBehaviour = (ImageTargetBehaviour)trackableBehaviour;
if (dataSet != null)
{
editorImgTargetBehaviour.SetDataSetPath(dataSet.Path);
}
editorImgTargetBehaviour.SetImageTargetType(trackable.ImageTargetType);
editorImgTargetBehaviour.SetNameForTrackable(trackable.Name);
editorImgTargetBehaviour.InitializeImageTarget(trackable);
mTrackableBehaviours[trackable.ID] = trackableBehaviour;
return(trackableBehaviour as ImageTargetBehaviour);
}
// Check if there are Trackables of different data sets in the scene.
private void CheckDataSets(TrackableBehaviour[] trackables)
{
string firstDataSet = "";
for (int i = 0; i < trackables.Length; ++i)
{
// Ignore non-data set trackables.
if (!(trackables[i] is DataSetTrackableBehaviour))
{
continue;
}
DataSetTrackableBehaviour dataSetTrackable = (DataSetTrackableBehaviour)trackables[i];
// Ignore default data sets...
if (dataSetTrackable.DataSetPath == QCARUtilities.GlobalVars.DEFAULT_DATA_SET_NAME)
{
continue;
}
if (firstDataSet == "")
{
firstDataSet = dataSetTrackable.DataSetName;
continue;
}
if (firstDataSet != dataSetTrackable.DataSetName)
{
Debug.LogWarning("Different Data Sets in scene detected. Only a single data set can be active in the scene.");
return;
}
}
}
internal ImageTargetAbstractBehaviour FindOrCreateImageTargetBehaviourForTrackable(ImageTarget trackable, GameObject gameObject, DataSet dataSet)
{
DataSetTrackableBehaviour component = gameObject.GetComponent <DataSetTrackableBehaviour>();
if (component == null)
{
component = BehaviourComponentFactory.Instance.AddImageTargetBehaviour(gameObject);
((IEditorTrackableBehaviour)component).SetInitializedInEditor(true);
}
if (!(component is ImageTargetAbstractBehaviour))
{
Debug.LogError(string.Format("DataSet.CreateTrackable: Trackable of type ImageTarget was created, but behaviour of type {0} was provided!", component.GetType()));
return(null);
}
IEditorImageTargetBehaviour behaviour2 = (ImageTargetAbstractBehaviour)component;
if (dataSet != null)
{
behaviour2.SetDataSetPath(dataSet.Path);
}
behaviour2.SetImageTargetType(trackable.ImageTargetType);
behaviour2.SetNameForTrackable(trackable.Name);
behaviour2.InitializeImageTarget(trackable);
this.mTrackableBehaviours[trackable.ID] = component;
return(component as ImageTargetAbstractBehaviour);
}
// Check for duplicate Trackables in the scene.
private void CheckForDuplicates(TrackableBehaviour[] trackables)
{
//Before we serialize we check for duplicates and provide a warning.
for (int i = 0; i < trackables.Length; ++i)
{
string tNameA = trackables[i].TrackableName;
// Ignore default names...
if (tNameA == QCARUtilities.GlobalVars.DEFAULT_TRACKABLE_NAME)
{
continue;
}
for (int j = i + 1; j < trackables.Length; ++j)
{
string tNameB = trackables[j].TrackableName;
// Ignore default names...
if (tNameB == QCARUtilities.GlobalVars.DEFAULT_TRACKABLE_NAME)
{
continue;
}
// We need to handle data set Trackables differently than markers.
if (((trackables[i] is DataSetTrackableBehaviour) &&
(trackables[j] is DataSetTrackableBehaviour)))
{
DataSetTrackableBehaviour castedTrackableA = (DataSetTrackableBehaviour)trackables[i];
DataSetTrackableBehaviour castedTrackableB = (DataSetTrackableBehaviour)trackables[j];
string tDataA = castedTrackableA.DataSetName;
string tDataB = castedTrackableB.DataSetName;
// Ignore Data Set Trackables that don't belong to the same data set.
if (tDataA.IndexOf(tDataB) != 0)
{
continue;
}
}
else if (!((trackables[i] is MarkerBehaviour) &&
(trackables[j] is MarkerBehaviour)))
{
// Ignore trackables that are of different type.
// Note: Multi Targets and Image Targets still need to have
// different names.
continue;
}
if (tNameA == tNameB)
{
Debug.LogWarning("Duplicate Trackables detected: \"" +
tNameA +
"\". Only one of the Trackables and its respective Augmentation " +
"will be selected for use at runtime - " +
"that selection is indeterminate here.");
}
}
}
}
private void DestroyTrackables(DataSet dataSet)
{
int numTrackables = dataSet.GetNumTrackables();
for (int i = 0; i < numTrackables; ++i)
{
DataSetTrackableBehaviour objToDestroy = dataSet.GetTrackable(i);
if (objToDestroy != null)
{
GameObject.Destroy(objToDestroy.gameObject);
}
}
}
// Updates trackables in scene from config data.
private void UpdateTrackableProperties(TrackableBehaviour[] trackables)
{
foreach (TrackableBehaviour tb in trackables)
{
// Ignore non-data set trackables.
if (!(tb is DataSetTrackableBehaviour))
{
continue;
}
DataSetTrackableBehaviour trackable = (DataSetTrackableBehaviour)tb;
TrackableAccessor configApplier = AccessorFactory.Create(trackable);
configApplier.ApplyDataSetProperties();
}
}
private void UpdateTrackableProperties(TrackableBehaviour[] trackables)
{
foreach (TrackableBehaviour behaviour in trackables)
{
if (behaviour is DataSetTrackableBehaviour)
{
DataSetTrackableBehaviour target = (DataSetTrackableBehaviour)behaviour;
TrackableAccessor accessor = AccessorFactory.Create(target);
if (accessor != null)
{
accessor.ApplyDataSetProperties();
}
}
}
}
private void CheckForDuplicates(TrackableBehaviour[] trackables)
{
HashSet <string> hashSet = new HashSet <string>();
for (int i = 0; i < trackables.Length; i++)
{
string trackableName = trackables[i].TrackableName;
if (!(trackableName == "--- EMPTY ---"))
{
for (int j = i + 1; j < trackables.Length; j++)
{
string trackableName2 = trackables[j].TrackableName;
if (!(trackableName2 == "--- EMPTY ---") && trackables[i] is DataSetTrackableBehaviour && trackables[j] is DataSetTrackableBehaviour)
{
DataSetTrackableBehaviour dataSetTrackableBehaviour = trackables[i] as DataSetTrackableBehaviour;
DataSetTrackableBehaviour arg_70_0 = trackables[j] as DataSetTrackableBehaviour;
string dataSetName = dataSetTrackableBehaviour.DataSetName;
string dataSetName2 = arg_70_0.DataSetName;
if (!(dataSetName != dataSetName2) && trackableName == trackableName2)
{
hashSet.Add(trackableName);
}
}
}
}
}
if (hashSet.Count > 0)
{
StringBuilder stringBuilder = new StringBuilder();
bool flag = true;
foreach (string current in hashSet)
{
if (flag)
{
stringBuilder.AppendFormat("'{0}'", current);
flag = false;
}
else
{
stringBuilder.AppendFormat(", '{0}'", current);
}
}
UnityEngine.Debug.LogWarning("Duplicate Trackables detected for: " + stringBuilder.ToString() + ".\nOnly one of the Trackables and its respective Augmentation will be selected for use at runtime - that selection is indeterminate here.");
}
}
private void UpdateTrackableAppearance(TrackableBehaviour[] trackables)
{
if (!Application.isPlaying)
{
foreach (TrackableBehaviour behaviour in trackables)
{
if (behaviour is DataSetTrackableBehaviour)
{
DataSetTrackableBehaviour target = (DataSetTrackableBehaviour)behaviour;
TrackableAccessor accessor = AccessorFactory.Create(target);
if (accessor != null)
{
accessor.ApplyDataSetAppearance();
}
}
}
}
}
// Returns the Trackable at the given index.
public DataSetTrackableBehaviour GetTrackable(int index)
{
Dictionary <int, DataSetTrackableBehaviour> .Enumerator enumerator =
mTrackableBehaviourDict.GetEnumerator();
DataSetTrackableBehaviour tb = null;
for (int i = 0; i <= index; ++i)
{
if (!enumerator.MoveNext())
{
Debug.LogError("Trackable index invalid.");
tb = null;
break;
}
tb = enumerator.Current.Value;
}
return(tb);
}
void MakeTrackable(Texture2D trackableTexture, Texture2D overlayTexture)
{
ObjectTracker objectTracker = TrackerManager.Instance.GetTracker <ObjectTracker>();
objectTracker.DestroyAllDataSets(true);
DataSet dataSet = objectTracker.CreateDataSet();
objectTracker.RuntimeImageSource.SetImage(trackableTexture, 0.16f, "newTargetImage");
DataSetTrackableBehaviour tbh = dataSet.CreateTrackable(objectTracker.RuntimeImageSource, "NewTrackableObject");
tbh.gameObject.AddComponent <DefaultTrackableEventHandler>();
tbh.gameObject.AddComponent <TurnOffBehaviour>();
tbh.RegisterOnTrackableStatusChanged(statusChange =>
{
if (statusChange.NewStatus.Equals(TrackableBehaviour.Status.NO_POSE))
{
mServerFoundTrackable = false;
StartCoroutine(PutCameraImage());
}
else if (statusChange.NewStatus.Equals(TrackableBehaviour.Status.TRACKED))
{
mServerFoundTrackable = true;
}
});
// Create quad to display image
GameObject childQuad = GameObject.CreatePrimitive(PrimitiveType.Quad);
MeshRenderer meshRenderer = childQuad.GetComponent <MeshRenderer>();
meshRenderer.sharedMaterial = new Material(Shader.Find("Standard"));
meshRenderer.sharedMaterial.SetTexture("_MainTex", overlayTexture);
childQuad.transform.parent = tbh.gameObject.transform;
childQuad.transform.localScale = new Vector3(overlayTexture.width / (float)overlayTexture.height, 1f, 1f);
childQuad.transform.Rotate(new Vector3(90f, 0f, 0f));
// End quad
objectTracker.ActivateDataSet(dataSet);
}
// Updates trackables in scene from config data.
private void UpdateTrackableAppearance(TrackableBehaviour[] trackables)
{
// do not set appearance in play mode
if (!Application.isPlaying)
{
foreach (TrackableBehaviour tb in trackables)
{
// Ignore non-data set trackables.
if (!(tb is DataSetTrackableBehaviour))
{
continue;
}
DataSetTrackableBehaviour trackable = (DataSetTrackableBehaviour)tb;
TrackableAccessor configApplier = AccessorFactory.Create(trackable);
if (configApplier != null)
{
configApplier.ApplyDataSetAppearance();
}
}
}
}
public void UpdateCameraPose(Camera arCamera,
QCARManager.TrackableData[] trackableDataArray,
int originTrackableID)
{
if (mActiveDataSet == null)
{
return;
}
// If there is a World Center Trackable use it to position the camera.
if (originTrackableID >= 0)
{
foreach (QCARManager.TrackableData trackableData in trackableDataArray)
{
if (trackableData.id == originTrackableID)
{
if (trackableData.status ==
TrackableBehaviour.Status.DETECTED ||
trackableData.status ==
TrackableBehaviour.Status.TRACKED)
{
DataSetTrackableBehaviour originTrackable = null;
if (mActiveDataSet.TryGetTrackableByID(originTrackableID,
out originTrackable))
{
if (originTrackable.enabled)
{
PositionCamera(originTrackable, arCamera,
trackableData.pose);
}
}
}
break;
}
}
}
}
public string GetDataSetName()
{
return(DataSetTrackableBehaviour.GetDataSetName(this.mDataSetPath.stringValue));
}
private bool IsTrackableInArray(DataSetTrackableBehaviour[] trackables, string trackableName)
{
bool trackableInArray = false;
foreach (DataSetTrackableBehaviour trackable in trackables)
{
if (mPath == trackable.DataSetPath &&
mStorageType == trackable.DataSetStorageType)
{
if (trackableName == trackable.TrackableName)
{
trackableInArray = true;
}
}
}
return trackableInArray;
}
private void AddTrackables(DataSetTrackableBehaviour[] trackableBehaviours)
{
// Initialize all Image Targets
foreach (DataSetTrackableBehaviour trackable in trackableBehaviours)
{
if (trackable.TrackableName == null)
{
Debug.LogError("Found Trackable without name.");
continue;
}
int id = -1;
if (trackable is ImageTargetBehaviour)
{
id = trackableGetId(trackable.TrackableName, mDataSetPtr);
if (id >= 0)
{
// Handle any changes to the image target in the scene
// that are not reflected in the config file
IntPtr sizePtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(Vector2)));
Marshal.StructureToPtr(((ImageTargetBehaviour)trackable).GetSize(), sizePtr, false);
// It is safe to assume that at loading stage the data set is not active.
imageTargetSetSize(mDataSetPtr, trackable.TrackableName, sizePtr);
Marshal.FreeHGlobal(sizePtr);
}
}
else if (trackable is MultiTargetBehaviour)
{
id = trackableGetId(trackable.TrackableName, mDataSetPtr);
}
else
{
id = -1;
}
if (id >= 0)
{
trackable.InitializeID(id);
if (!mTrackableBehaviourDict.ContainsKey(id))
{
mTrackableBehaviourDict[id] = trackable;
Debug.Log("Found Trackable named " + trackable.TrackableName +
" with id " + trackable.TrackableID);
}
}
}
}
// Returns the Trackable with the given unique ID.
// Unique IDs for Trackables are created when data sets are loaded.
public bool TryGetTrackableByID(int id,
out DataSetTrackableBehaviour trackable)
{
return mTrackableBehaviourDict.TryGetValue(id, out trackable);
}
// Returns the Trackable with the given unique ID.
// Unique IDs for Trackables are created when data sets are loaded.
public bool TryGetTrackableByID(int id,
out DataSetTrackableBehaviour trackable)
{
return(mTrackableBehaviourDict.TryGetValue(id, out trackable));
}
// This method creates a single data set from the trackables provided.
// The method ignores the data set property in TrackableBehaviour and
// adds all Trackables to a single file.
// Default Trackables are not added to the data set.
private ConfigData CreateDataSetFromTrackables(TrackableBehaviour[] trackables)
{
// Sanity check.
if (trackables == null)
{
return(null);
}
ConfigData sceneData = new ConfigData();
foreach (TrackableBehaviour tb in trackables)
{
// Ignore non-data set trackables.
if (!(tb is DataSetTrackableBehaviour))
{
continue;
}
DataSetTrackableBehaviour trackable = (DataSetTrackableBehaviour)tb;
string dataSetName = trackable.DataSetName;
string trackableName = trackable.TrackableName;
// We ignore default Trackables or undefined Trackables.
if (dataSetName == QCARUtilities.GlobalVars.DEFAULT_DATA_SET_NAME ||
dataSetName == "" ||
trackableName == QCARUtilities.GlobalVars.DEFAULT_TRACKABLE_NAME ||
trackableName == "")
{
Debug.LogWarning("Ignoring default Trackable for export");
continue;
}
if (trackable.GetType() == typeof(ImageTargetBehaviour))
{
ImageTargetBehaviour it = (ImageTargetBehaviour)trackable;
ConfigData.ImageTarget itConfig = new ConfigData.ImageTarget();
itConfig.size = it.GetSize();
// Process Virtual Button list.
VirtualButtonBehaviour[] vbs =
it.GetComponentsInChildren <VirtualButtonBehaviour>();
itConfig.virtualButtons = new List <ConfigData.VirtualButton>(vbs.Length);
foreach (VirtualButtonBehaviour vb in vbs)
{
Vector2 leftTop;
Vector2 rightBottom;
if (!vb.CalculateButtonArea(out leftTop,
out rightBottom))
{
// Invalid Button
continue;
}
ConfigData.VirtualButton vbConfig =
new ConfigData.VirtualButton();
vbConfig.name = vb.VirtualButtonName;
vbConfig.enabled = vb.enabled;
vbConfig.rectangle = new Vector4(leftTop.x,
leftTop.y,
rightBottom.x,
rightBottom.y);
vbConfig.sensitivity = vb.SensitivitySetting;
itConfig.virtualButtons.Add(vbConfig);
}
sceneData.SetImageTarget(itConfig, it.TrackableName);
}
else if (trackable.GetType() == typeof(MultiTargetBehaviour))
{
Debug.Log("Multi Targets not exported.");
}
}
return(sceneData);
}
