public override void ApplyDataSetProperties()
{
if (QCARUtilities.GetPrefabType(base.mTarget) != PrefabType.Prefab)
{
ConfigData.ImageTargetData data;
ImageTargetAbstractBehaviour mTarget = (ImageTargetAbstractBehaviour)base.mTarget;
IEditorImageTargetBehaviour behaviour2 = mTarget;
if (this.TrackableInDataSet(behaviour2.TrackableName, behaviour2.DataSetName))
{
ConfigDataManager.Instance.GetConfigData(behaviour2.DataSetName).GetImageTarget(behaviour2.TrackableName, out data);
}
else if (behaviour2.ImageTargetType != ImageTargetType.PREDEFINED)
{
data = QCARUtilities.CreateDefaultImageTarget();
}
else
{
ConfigDataManager.Instance.GetConfigData("--- EMPTY ---").GetImageTarget("--- EMPTY ---", out data);
behaviour2.SetDataSetPath("--- EMPTY ---");
behaviour2.SetNameForTrackable("--- EMPTY ---");
}
ImageTargetEditor.UpdateScale(mTarget, data.size);
ImageTargetEditor.UpdateVirtualButtons(mTarget, data.virtualButtons.ToArray());
}
}
/// Handles new search results
/// <param name="targetSearchResult"></param>
public void OnNewSearchResult(TargetFinder.TargetSearchResult targetSearchResult)
{
// duplicate the referenced image target
GameObject newImageTarget = Instantiate(ImageTargetTemplate.gameObject) as GameObject;
GameObject augmentation = null;
string model_name = targetSearchResult.MetaData;
if (augmentation != null)
{
augmentation.transform.parent = newImageTarget.transform;
}
// enable the new result with the same ImageTargetBehaviour:
ImageTargetAbstractBehaviour imageTargetBehaviour =
mImageTracker.TargetFinder.EnableTracking(targetSearchResult, newImageTarget);
Debug.Log("Metadata value is " + model_name);
mTargetMetadata = model_name;
if (!mIsScanning)
{
// stop the target finder
mCloudRecoBehaviour.CloudRecoEnabled = true;
}
}
public void OnEnable()
{
ImageTargetAbstractBehaviour arg_22_0 = (ImageTargetAbstractBehaviour)base.target;
this.mSerializedObject = new SerializedImageTarget(base.serializedObject);
ImageTargetEditor.EditorConfigureTarget(arg_22_0, this.mSerializedObject);
}
internal static void UpdateVirtualButtons(ImageTargetAbstractBehaviour it, ConfigData.VirtualButtonData[] vbs)
{
for (int i = 0; i < vbs.Length; i++)
{
VirtualButtonAbstractBehaviour[] componentsInChildren = it.GetComponentsInChildren <VirtualButtonAbstractBehaviour>();
bool flag = false;
for (int j = 0; j < componentsInChildren.Length; j++)
{
if (componentsInChildren[j].VirtualButtonName == vbs[i].name)
{
SerializedObject serializedObject = new SerializedObject(componentsInChildren[j]);
using (serializedObject.Edit())
{
componentsInChildren[j].enabled = vbs[i].enabled;
VirtualButtonEditor.GetSensitivityProperty(serializedObject).enumValueIndex = (int)vbs[i].sensitivity;
componentsInChildren[j].SetPosAndScaleFromButtonArea(new Vector2(vbs[i].rectangle[0], vbs[i].rectangle[1]), new Vector2(vbs[i].rectangle[2], vbs[i].rectangle[3]));
}
flag = true;
}
}
if (!flag)
{
VirtualButtonEditor.AddVirtualButton(it, vbs[i]);
}
}
}
public override void ApplyDataSetProperties()
{
if (VuforiaUtilities.GetPrefabType(this.mTarget) == PrefabType.Prefab)
{
return;
}
ImageTargetAbstractBehaviour it = (ImageTargetAbstractBehaviour)this.mTarget;
ConfigData.ImageTargetData imageTargetData;
using (this.mSerializedObject.Edit())
{
if (this.TrackableInDataSet(this.mSerializedObject.TrackableName, this.mSerializedObject.GetDataSetName()))
{
ConfigDataManager.Instance.GetConfigData(this.mSerializedObject.GetDataSetName()).GetImageTarget(this.mSerializedObject.TrackableName, out imageTargetData);
}
else if (this.mSerializedObject.ImageTargetType != ImageTargetType.PREDEFINED)
{
imageTargetData = VuforiaUtilities.CreateDefaultImageTarget();
}
else
{
ConfigDataManager.Instance.GetConfigData("--- EMPTY ---").GetImageTarget("--- EMPTY ---", out imageTargetData);
this.mSerializedObject.DataSetPath = "--- EMPTY ---";
this.mSerializedObject.TrackableName = "--- EMPTY ---";
}
ImageTargetEditor.UpdateScale(this.mSerializedObject, imageTargetData.size);
}
VirtualButtonEditor.UpdateVirtualButtons(it, imageTargetData.virtualButtons.ToArray());
}
public static void EditorConfigureTarget(ImageTargetAbstractBehaviour itb, SerializedImageTarget serializedObject)
{
if (itb == null)
{
Debug.LogError("ImageTargetAbstractBehaviour parameter is null !");
return;
}
if (VuforiaUtilities.GetPrefabType(itb) == PrefabType.Prefab)
{
return;
}
if (!SceneManager.Instance.SceneInitialized)
{
SceneManager.Instance.InitScene();
}
using (serializedObject.Edit())
{
if (!serializedObject.InitializedInEditor && !EditorApplication.isPlaying)
{
ConfigData.ImageTargetData imageTargetData;
ConfigDataManager.Instance.GetConfigData("--- EMPTY ---").GetImageTarget("--- EMPTY ---", out imageTargetData);
serializedObject.DataSetPath = "--- EMPTY ---";
serializedObject.TrackableName = "--- EMPTY ---";
ImageTargetEditor.UpdateAspectRatio(serializedObject, imageTargetData.size);
ImageTargetEditor.UpdateScale(serializedObject, imageTargetData.size);
ImageTargetEditor.UpdateMaterial(serializedObject);
serializedObject.InitializedInEditor = true;
}
else if (!EditorApplication.isPlaying)
{
ImageTargetEditor.CheckMesh(serializedObject);
}
}
}
public void OnEnable()
{
ImageTargetAbstractBehaviour target = (ImageTargetAbstractBehaviour)base.target;
if (QCARUtilities.GetPrefabType(target) != PrefabType.Prefab)
{
if (!SceneManager.Instance.SceneInitialized)
{
SceneManager.Instance.InitScene();
}
IEditorImageTargetBehaviour it = target;
if (!it.InitializedInEditor && !EditorApplication.isPlaying)
{
ConfigData.ImageTargetData data;
ConfigDataManager.Instance.GetConfigData("--- EMPTY ---").GetImageTarget("--- EMPTY ---", out data);
UpdateAspectRatio(target, data.size);
UpdateScale(target, data.size);
UpdateMaterial(target);
it.SetDataSetPath("--- EMPTY ---");
it.SetNameForTrackable("--- EMPTY ---");
it.SetInitializedInEditor(true);
}
else if (!EditorApplication.isPlaying)
{
CheckMesh(it);
}
it.SetPreviousScale(target.transform.localScale);
}
}
public static void AddVirtualButtons(ImageTargetAbstractBehaviour it, ConfigData.VirtualButtonData[] vbs)
{
for (int i = 0; i < vbs.Length; i++)
{
AddVirtualButton(it, vbs[i]);
}
}
private void CreateMissingDataSetTrackableBehaviours(DataSet dataSet)
{
foreach (Trackable trackable in dataSet.GetTrackables())
{
if (!this.mTrackableBehaviours.ContainsKey(trackable.ID))
{
if (trackable is ImageTarget)
{
ImageTargetAbstractBehaviour behaviour = this.CreateImageTargetBehaviour((ImageTarget)trackable);
((IEditorImageTargetBehaviour)behaviour).CreateMissingVirtualButtonBehaviours();
this.mTrackableBehaviours[trackable.ID] = behaviour;
this.mAutomaticallyCreatedBehaviours.Add(trackable.ID);
}
else if (trackable is MultiTarget)
{
MultiTargetAbstractBehaviour behaviour2 = this.CreateMultiTargetBehaviour((MultiTarget)trackable);
this.mTrackableBehaviours[trackable.ID] = behaviour2;
this.mAutomaticallyCreatedBehaviours.Add(trackable.ID);
}
else if (trackable is CylinderTarget)
{
CylinderTargetAbstractBehaviour behaviour3 = this.CreateCylinderTargetBehaviour((CylinderTarget)trackable);
this.mTrackableBehaviours[trackable.ID] = behaviour3;
this.mAutomaticallyCreatedBehaviours.Add(trackable.ID);
}
}
}
}
private ConfigData CreateDataSetFromTrackables(TrackableBehaviour[] trackables)
{
if (trackables == null)
{
return(null);
}
ConfigData data = new ConfigData();
foreach (TrackableBehaviour behaviour in trackables)
{
if (behaviour is DataSetTrackableBehaviour)
{
IEditorDataSetTrackableBehaviour behaviour2 = (DataSetTrackableBehaviour)behaviour;
string dataSetName = behaviour2.DataSetName;
string trackableName = behaviour2.TrackableName;
if (((dataSetName == "--- EMPTY ---") || (dataSetName == "")) || ((trackableName == "--- EMPTY ---") || (trackableName == "")))
{
UnityEngine.Debug.LogWarning("Ignoring default Trackable for export");
}
else if (behaviour2 is ImageTargetAbstractBehaviour)
{
ImageTargetAbstractBehaviour behaviour3 = (ImageTargetAbstractBehaviour)behaviour2;
IEditorImageTargetBehaviour behaviour4 = behaviour3;
ConfigData.ImageTargetData item = new ConfigData.ImageTargetData {
size = behaviour4.GetSize()
};
VirtualButtonAbstractBehaviour[] componentsInChildren = behaviour3.GetComponentsInChildren <VirtualButtonAbstractBehaviour>();
item.virtualButtons = new List <ConfigData.VirtualButtonData>(componentsInChildren.Length);
foreach (VirtualButtonAbstractBehaviour behaviour5 in componentsInChildren)
{
Vector2 vector;
Vector2 vector2;
if (behaviour5.CalculateButtonArea(out vector, out vector2))
{
ConfigData.VirtualButtonData data3 = new ConfigData.VirtualButtonData();
IEditorVirtualButtonBehaviour behaviour6 = behaviour5;
data3.name = behaviour6.VirtualButtonName;
data3.enabled = behaviour6.enabled;
data3.rectangle = new Vector4(vector.x, vector.y, vector2.x, vector2.y);
data3.sensitivity = behaviour6.SensitivitySetting;
item.virtualButtons.Add(data3);
}
}
data.SetImageTarget(item, behaviour4.TrackableName);
}
else if (behaviour2 is MultiTargetAbstractBehaviour)
{
UnityEngine.Debug.Log("Multi Targets not exported.");
}
else if (behaviour2 is CylinderTargetAbstractBehaviour)
{
UnityEngine.Debug.Log("Cylinder Targets not exported.");
}
}
}
return(data);
}
void Start()
{
DT_ImageTarget = FindObjectOfType(typeof(ImageTargetAbstractBehaviour)) as ImageTargetAbstractBehaviour;
mTrackableBehaviour = GetComponent <TrackableBehaviour>();
if (mTrackableBehaviour)
{
mTrackableBehaviour.RegisterTrackableEventHandler(this);
}
}
private void OnTrackingFound()
{
if (mTrackableBehaviour is ImageTargetAbstractBehaviour)
{
ImageTargetAbstractBehaviour itb = mTrackableBehaviour as ImageTargetAbstractBehaviour;
ImageTarget it = itb.ImageTarget;
SetActivityInNativePlugin();
ShowTargetInfo(it.Name, it.GetSize().x, it.GetSize().y);
}
}
private void OnDestroy()
{
if (Application.isPlaying && this.mUnregisterOnDestroy)
{
ImageTargetAbstractBehaviour imageTargetBehaviour = this.GetImageTargetBehaviour();
if (imageTargetBehaviour != null)
{
imageTargetBehaviour.ImageTarget.DestroyVirtualButton(this.mVirtualButton);
}
}
}
private static void DetectDuplicates(ImageTargetAbstractBehaviour it)
{
IEditorImageTargetBehaviour behaviour = it;
VirtualButtonAbstractBehaviour[] componentsInChildren = it.GetComponentsInChildren <VirtualButtonAbstractBehaviour>();
for (int i = 0; i < componentsInChildren.Length; i++)
{
for (int j = i + 1; j < componentsInChildren.Length; j++)
{
if (componentsInChildren[i].VirtualButtonName == componentsInChildren[j].VirtualButtonName)
{
Debug.LogError("Duplicate virtual buttons with name '" + componentsInChildren[i].VirtualButtonName + "' detected in Image Target '" + behaviour.TrackableName + "'.");
}
}
}
}
/// Handles new search results
public void OnNewSearchResult(TargetFinder.TargetSearchResult targetSearchResult)
{
// duplicate the referenced image target - THIS THE CLONE IMAGE TARGET ON WITH THE OBJECT APEARS
GameObject newImageTarget = Instantiate(ImageTargetTemplate.gameObject) as GameObject;
// GETTING THE META DATA OF IMAGE TARGET
string model_name = targetSearchResult.MetaData;
// enable the new result with the same ImageTargetBehaviour:
ImageTargetAbstractBehaviour imageTargetBehaviour = mImageTracker.TargetFinder.EnableTracking(targetSearchResult, newImageTarget);
Debug.Log("Metadata value is = " + model_name);
mTargetMetadata = model_name; //setting the global variable with the model name
//======== clearing the previously set object ========
arrayListOfModelName.Add(model_name); //adding the model name to the array list of model names
if (arrayListOfModelName.Count > 1)
{
String nameOfGameObjectToDestroy = (String)arrayListOfModelName[arrayListOfModelName.Count - 2]; //getting the previous objects name
Debug.Log("nameOfGameObjectToDestroy === === == " + nameOfGameObjectToDestroy);
GameObject gameObjectToDestroy = GameObject.Find(nameOfGameObjectToDestroy + "(Clone)"); //finding the object to destroy
Destroy(gameObjectToDestroy); //destroying the object
}
//============== this method call makes the object visble on the target image ==============
StartCoroutine(DownloadObject(model_name));
//==========================================================================================
if (!mIsScanning)
{
// stop the target finder
mCloudRecoBehaviour.CloudRecoEnabled = true;
}
}
private static void AddVirtualButton(ImageTargetAbstractBehaviour it, ConfigData.VirtualButtonData vb)
{
IEditorVirtualButtonBehaviour behaviour = it.CreateVirtualButton(vb.name, new Vector2(0f, 0f), new Vector2(1f, 1f));
if (behaviour != null)
{
behaviour.SetPosAndScaleFromButtonArea(new Vector2(vb.rectangle[0], vb.rectangle[1]), new Vector2(vb.rectangle[2], vb.rectangle[3]));
VirtualButtonEditor.CreateVBMesh(behaviour);
VirtualButtonEditor.CreateMaterial(behaviour);
behaviour.enabled = vb.enabled;
BehaviourComponentFactory.Instance.AddTurnOffBehaviour(behaviour.gameObject);
behaviour.UpdatePose();
}
else
{
Debug.LogError("VirtualButton could not be added!");
}
}
private ImageTargetAbstractBehaviour CreateImageTargetBehaviour(ImageTarget imageTarget)
{
GameObject gameObject = new GameObject();
ImageTargetAbstractBehaviour behaviour = BehaviourComponentFactory.Instance.AddImageTargetBehaviour(gameObject);
IEditorImageTargetBehaviour behaviour2 = behaviour;
Debug.Log(string.Concat(new object[] { "Creating Image Target with values: \n ID: ", imageTarget.ID, "\n Name: ", imageTarget.Name, "\n Path: ", behaviour2.DataSetPath, "\n Size: ", imageTarget.GetSize().x, "x", imageTarget.GetSize().y }));
behaviour2.SetNameForTrackable(imageTarget.Name);
behaviour2.SetDataSetPath(behaviour2.DataSetPath);
Vector2 size = imageTarget.GetSize();
float x = Mathf.Max(size.x, size.y);
behaviour2.transform.localScale = new Vector3(x, x, x);
behaviour2.CorrectScale();
behaviour2.SetAspectRatio(size.y / size.x);
behaviour2.InitializeImageTarget(imageTarget);
return(behaviour);
}
bool IEditorVirtualButtonBehaviour.SetPosAndScaleFromButtonArea(Vector2 topLeft, Vector2 bottomRight)
{
ImageTargetAbstractBehaviour imageTargetBehaviour = this.GetImageTargetBehaviour();
if (imageTargetBehaviour == null)
{
return(false);
}
float num = imageTargetBehaviour.transform.lossyScale[0];
Vector2 vector = (Vector2)((topLeft + bottomRight) * 0.5f);
Vector2 vector2 = new Vector2(bottomRight[0] - topLeft[0], topLeft[1] - bottomRight[1]);
Vector3 position = new Vector3(vector[0] / num, 0.001f, vector[1] / num);
Vector3 vector4 = new Vector3(vector2[0], (vector2[0] + vector2[1]) * 0.5f, vector2[1]);
base.transform.position = imageTargetBehaviour.transform.TransformPoint(position);
base.transform.localScale = (Vector3)(vector4 / base.transform.parent.lossyScale[0]);
return(true);
}
/// <summary>
/// Handles new search results
/// </summary>
/// <param name="targetSearchResult"></param>
public void OnNewSearchResult(TargetFinder.TargetSearchResult targetSearchResult)
{
// duplicate the referenced image target
GameObject newImageTarget = Instantiate(ImageTargetTemplate.gameObject) as GameObject;
GameObject augmentation = null;
string model_name = targetSearchResult.MetaData;
if (augmentation != null)
{
augmentation.transform.parent = newImageTarget.transform;
}
// enable the new result with the same ImageTargetBehaviour:
ImageTargetAbstractBehaviour imageTargetBehaviour = mImageTracker.TargetFinder.EnableTracking(targetSearchResult, newImageTarget);
//Debug.Log("Metadata value is " + model_name );
ndbno = model_name;
switch (model_name)
{
case "bettycrocker":
//Destroy( imageTargetBehaviour.gameObject.transform.Find("Button").gameObject );
break;
case "Capsule":
Destroy(imageTargetBehaviour.gameObject.transform.Find("Cube").gameObject);
break;
}
if (!mIsScanning)
{
// stop the target finder
mCloudRecoBehaviour.CloudRecoEnabled = true;
}
}
public ImageTargetAbstractBehaviour GetImageTargetBehaviour()
{
if (base.transform.parent != null)
{
for (GameObject obj2 = base.transform.parent.gameObject; obj2 != null; obj2 = obj2.transform.parent.gameObject)
{
ImageTargetAbstractBehaviour component = obj2.GetComponent <ImageTargetAbstractBehaviour>();
if (component != null)
{
return(component);
}
if (obj2.transform.parent == null)
{
return(null);
}
}
}
return(null);
}
public bool CalculateButtonArea(out Vector2 topLeft, out Vector2 bottomRight)
{
ImageTargetAbstractBehaviour imageTargetBehaviour = this.GetImageTargetBehaviour();
if (imageTargetBehaviour == null)
{
topLeft = bottomRight = Vector2.zero;
return(false);
}
Vector3 vector = imageTargetBehaviour.transform.InverseTransformPoint(base.transform.position);
float num = imageTargetBehaviour.transform.lossyScale[0];
Vector2 vector2 = new Vector2(vector[0] * num, vector[2] * num);
Vector2 vector3 = new Vector2(base.transform.lossyScale[0], base.transform.lossyScale[2]);
Vector2 vector4 = Vector2.Scale((Vector2)(vector3 * 0.5f), new Vector2(1f, -1f));
topLeft = vector2 - vector4;
bottomRight = vector2 + vector4;
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 bool UpdatePose()
{
Vector2 vector3;
Vector2 vector4;
ImageTargetAbstractBehaviour imageTargetBehaviour = this.GetImageTargetBehaviour();
if (imageTargetBehaviour == null)
{
return(false);
}
for (Transform transform = base.transform.parent; transform != null; transform = transform.parent)
{
if ((transform.localScale[0] != transform.localScale[1]) || (transform.localScale[0] != transform.localScale[2]))
{
Debug.LogWarning("Detected non-uniform scale in virtual button object hierarchy. Forcing uniform scaling of object '" + transform.name + "'.");
transform.localScale = new Vector3(transform.localScale[0], transform.localScale[0], transform.localScale[0]);
}
}
this.mHasUpdatedPose = true;
if ((base.transform.parent != null) && (base.transform.parent.gameObject != imageTargetBehaviour.gameObject))
{
base.transform.localPosition = Vector3.zero;
}
Vector3 position = imageTargetBehaviour.transform.InverseTransformPoint(base.transform.position);
position.y = 0.001f;
Vector3 vector2 = imageTargetBehaviour.transform.TransformPoint(position);
base.transform.position = vector2;
base.transform.rotation = imageTargetBehaviour.transform.rotation;
this.CalculateButtonArea(out vector3, out vector4);
float threshold = imageTargetBehaviour.transform.localScale[0] * 0.001f;
if (Equals(vector3, this.mLeftTop, threshold) && Equals(vector4, this.mRightBottom, threshold))
{
return(false);
}
this.mLeftTop = vector3;
this.mRightBottom = vector4;
return(true);
}
private static void AddVirtualButton(ImageTargetAbstractBehaviour it, ConfigData.VirtualButtonData vb)
{
VirtualButtonAbstractBehaviour virtualButtonAbstractBehaviour = it.CreateVirtualButton(vb.name, new Vector2(0f, 0f), new Vector2(1f, 1f));
if (virtualButtonAbstractBehaviour != null)
{
SerializedObject serializedObject = new SerializedObject(virtualButtonAbstractBehaviour);
using (serializedObject.Edit())
{
VirtualButtonEditor.GetSensitivityProperty(serializedObject).enumValueIndex = (int)vb.sensitivity;
}
virtualButtonAbstractBehaviour.SetPosAndScaleFromButtonArea(new Vector2(vb.rectangle[0], vb.rectangle[1]), new Vector2(vb.rectangle[2], vb.rectangle[3]));
VirtualButtonEditor.CreateVBMesh(virtualButtonAbstractBehaviour.gameObject);
VirtualButtonEditor.CreateMaterial(virtualButtonAbstractBehaviour.gameObject);
virtualButtonAbstractBehaviour.enabled = vb.enabled;
BehaviourComponentFactory.Instance.AddTurnOffBehaviour(virtualButtonAbstractBehaviour.gameObject);
virtualButtonAbstractBehaviour.UpdatePose();
return;
}
Debug.LogError("VirtualButton could not be added!");
}
private static void DetectDuplicates(ImageTargetAbstractBehaviour it)
{
VirtualButtonAbstractBehaviour[] componentsInChildren = it.GetComponentsInChildren <VirtualButtonAbstractBehaviour>();
for (int i = 0; i < componentsInChildren.Length; i++)
{
for (int j = i + 1; j < componentsInChildren.Length; j++)
{
if (componentsInChildren[i].VirtualButtonName == componentsInChildren[j].VirtualButtonName)
{
Debug.LogError(string.Concat(new string[]
{
"Duplicate virtual buttons with name '",
componentsInChildren[i].VirtualButtonName,
"' detected in Image Target '",
it.TrackableName,
"'."
}));
}
}
}
}
public override void OnInspectorGUI()
{
EditorGUIUtility.LookLikeInspector();
base.DrawDefaultInspector();
ImageTargetAbstractBehaviour target = (ImageTargetAbstractBehaviour)base.target;
IEditorImageTargetBehaviour behaviour2 = target;
if (QCARUtilities.GetPrefabType(target) == PrefabType.Prefab)
{
GUILayout.Label("You can't choose a target for a prefab.", new GUILayoutOption[0]);
}
else
{
ImageTargetType imageTargetType = behaviour2.ImageTargetType;
string[] displayedOptions = new string[] { "Predefined", "User Defined", "Cloud Reco" };
ImageTargetType[] typeArray2 = new ImageTargetType[3];
typeArray2[1] = ImageTargetType.USER_DEFINED;
typeArray2[2] = ImageTargetType.CLOUD_RECO;
ImageTargetType[] source = typeArray2;
behaviour2.SetImageTargetType(source[EditorGUILayout.Popup("Type", source.ToList <ImageTargetType>().IndexOf(behaviour2.ImageTargetType), displayedOptions, new GUILayoutOption[0])]);
bool typeChanged = behaviour2.ImageTargetType != imageTargetType;
if (behaviour2.ImageTargetType == ImageTargetType.PREDEFINED)
{
this.DrawPredefinedTargetInsprectorUI(target, typeChanged);
}
else if (behaviour2.ImageTargetType == ImageTargetType.USER_DEFINED)
{
this.DrawUserDefinedTargetInspectorUI(target, typeChanged);
}
else
{
this.DrawCloudRecoTargetInspectorUI(target, typeChanged);
}
}
if (GUI.changed)
{
EditorUtility.SetDirty(target);
SceneManager.Instance.SceneUpdated();
}
}
public static void UpdateVirtualButtons(ImageTargetAbstractBehaviour it, ConfigData.VirtualButtonData[] vbs)
{
for (int i = 0; i < vbs.Length; i++)
{
IEditorVirtualButtonBehaviour[] componentsInChildren = it.GetComponentsInChildren <VirtualButtonAbstractBehaviour>();
bool flag = false;
for (int j = 0; j < componentsInChildren.Length; j++)
{
if (componentsInChildren[j].VirtualButtonName == vbs[i].name)
{
componentsInChildren[j].enabled = vbs[i].enabled;
componentsInChildren[j].SetSensitivitySetting(vbs[i].sensitivity);
componentsInChildren[j].SetPosAndScaleFromButtonArea(new Vector2(vbs[i].rectangle[0], vbs[i].rectangle[1]), new Vector2(vbs[i].rectangle[2], vbs[i].rectangle[3]));
flag = true;
}
}
if (!flag)
{
AddVirtualButton(it, vbs[i]);
}
}
}
internal static void Validate()
{
ImageTargetAbstractBehaviour[] array = UnityEngine.Object.FindObjectsOfType <ImageTargetAbstractBehaviour>();
for (int i = 0; i < array.Length; i++)
{
VirtualButtonEditor.DetectDuplicates(array[i]);
}
VirtualButtonAbstractBehaviour[] array2 = UnityEngine.Object.FindObjectsOfType <VirtualButtonAbstractBehaviour>();
for (int i = 0; i < array2.Length; i++)
{
VirtualButtonAbstractBehaviour virtualButtonAbstractBehaviour = array2[i];
ImageTargetAbstractBehaviour imageTargetBehaviour = virtualButtonAbstractBehaviour.GetImageTargetBehaviour();
if (imageTargetBehaviour == null)
{
Debug.LogError("Virtual Button '" + virtualButtonAbstractBehaviour.name + "' doesn't have an Image Target as an ancestor.");
}
else if (imageTargetBehaviour.ImageTargetType == ImageTargetType.USER_DEFINED)
{
Debug.LogError("Virtual Button '" + virtualButtonAbstractBehaviour.name + "' cannot be added to a user defined target.");
}
}
}
internal void UpdateVirtualButtons(int numVirtualButtons, IntPtr virtualButtonPtr)
{
Dictionary <int, QCARManagerImpl.VirtualButtonData> dictionary = new Dictionary <int, QCARManagerImpl.VirtualButtonData>();
for (int i = 0; i < numVirtualButtons; i++)
{
IntPtr ptr = new IntPtr(virtualButtonPtr.ToInt32() + (i * Marshal.SizeOf(typeof(QCARManagerImpl.VirtualButtonData))));
QCARManagerImpl.VirtualButtonData data = (QCARManagerImpl.VirtualButtonData)Marshal.PtrToStructure(ptr, typeof(QCARManagerImpl.VirtualButtonData));
dictionary.Add(data.id, data);
}
List <VirtualButtonAbstractBehaviour> list = new List <VirtualButtonAbstractBehaviour>();
foreach (TrackableBehaviour behaviour in this.mTrackableBehaviours.Values)
{
ImageTargetAbstractBehaviour behaviour2 = behaviour as ImageTargetAbstractBehaviour;
if ((behaviour2 != null) && behaviour2.enabled)
{
foreach (VirtualButtonAbstractBehaviour behaviour3 in behaviour2.GetVirtualButtonBehaviours())
{
if (behaviour3.enabled)
{
list.Add(behaviour3);
}
}
}
}
foreach (VirtualButtonAbstractBehaviour behaviour4 in list)
{
QCARManagerImpl.VirtualButtonData data2;
if (dictionary.TryGetValue(behaviour4.VirtualButton.ID, out data2))
{
behaviour4.OnTrackerUpdated(data2.isPressed > 0);
}
else
{
behaviour4.OnTrackerUpdated(false);
}
}
}
private void AssociateVirtualButtonBehaviours(VirtualButtonAbstractBehaviour[] vbBehaviours, DataSet dataSet)
{
for (int i = 0; i < vbBehaviours.Length; i++)
{
VirtualButtonAbstractBehaviour virtualButtonBehaviour = vbBehaviours[i];
if (virtualButtonBehaviour.VirtualButtonName == null)
{
Debug.LogError("VirtualButton at " + i + " has no name.");
}
else
{
ImageTargetAbstractBehaviour imageTargetBehaviour = virtualButtonBehaviour.GetImageTargetBehaviour();
if (imageTargetBehaviour == null)
{
Debug.LogError("VirtualButton named " + virtualButtonBehaviour.VirtualButtonName + " is not attached to an ImageTarget.");
}
else if (dataSet.Contains(imageTargetBehaviour.Trackable))
{
((IEditorImageTargetBehaviour)imageTargetBehaviour).AssociateExistingVirtualButtonBehaviour(virtualButtonBehaviour);
}
}
}
}
