// Updates the scale values in the transform component from a given size.
public static void UpdateScale(IEditorImageTargetBehaviour it, Vector2 size)
{
// Update the scale:
float childScaleFactor = it.GetSize()[0] / size[0];
if (it.AspectRatio <= 1.0f)
{
it.transform.localScale = new Vector3(size[0], size[0], size[0]);
}
else
{
it.transform.localScale = new Vector3(size[1], size[1], size[1]);
}
// Check if 3D content should keep its size or if it should be scaled
// with the target.
if (it.PreserveChildSize)
{
foreach (Transform child in it.transform)
{
child.localPosition =
new Vector3(child.localPosition.x * childScaleFactor,
child.localPosition.y * childScaleFactor,
child.localPosition.z * childScaleFactor);
child.localScale =
new Vector3(child.localScale.x * childScaleFactor,
child.localScale.y * childScaleFactor,
child.localScale.z * childScaleFactor);
}
}
}
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 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());
}
}
// This method updates the respective Trackable appearance (e.g.
// aspect ratio and texture) with data set data.
public override void ApplyDataSetAppearance()
{
// Prefabs should not be changed
if (QCARUtilities.GetPrefabType(mTarget) == PrefabType.Prefab)
{
return;
}
// Update the aspect ratio, visualization and scale of the target:
IEditorImageTargetBehaviour itb = (ImageTargetBehaviour)mTarget;
ConfigData.ImageTargetData itConfig;
if (TrackableInDataSet(itb.TrackableName, itb.DataSetName))
{
ConfigData dataSetData = ConfigDataManager.Instance.GetConfigData(itb.DataSetName);
dataSetData.GetImageTarget(itb.TrackableName, out itConfig);
}
else if (itb.ImageTargetType != ImageTargetType.PREDEFINED)
{
itConfig = QCARUtilities.CreateDefaultImageTarget();
}
else
{
// If the Trackable has been removed from the data set we reset it to default.
ConfigData dataSetData = ConfigDataManager.Instance.GetConfigData(QCARUtilities.GlobalVars.DEFAULT_DATA_SET_NAME);
dataSetData.GetImageTarget(QCARUtilities.GlobalVars.DEFAULT_TRACKABLE_NAME, out itConfig);
itb.SetDataSetPath(QCARUtilities.GlobalVars.DEFAULT_DATA_SET_NAME);
itb.SetNameForTrackable(QCARUtilities.GlobalVars.DEFAULT_TRACKABLE_NAME);
}
ImageTargetEditor.UpdateAspectRatio(itb, itConfig.size);
ImageTargetEditor.UpdateMaterial(itb);
}
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);
}
// This methods validates all Virtual Buttons in the scene and prints
// errors accordingly.
public static void Validate()
{
// First check for duplicate virtual buttons in all image targets
ImageTargetBehaviour[] its = (ImageTargetBehaviour[])
UnityEngine.Object.FindObjectsOfType(typeof(ImageTargetBehaviour));
foreach (ImageTargetBehaviour it in its)
{
DetectDuplicates(it);
}
// Check for Virtual Buttons that don't have an Image Target as an
// ancestor:
VirtualButtonBehaviour[] vbs = (VirtualButtonBehaviour[])
UnityEngine.Object.FindObjectsOfType(
typeof(VirtualButtonBehaviour));
foreach (VirtualButtonBehaviour vb in vbs)
{
IEditorImageTargetBehaviour it = vb.GetImageTargetBehaviour();
if (it == null)
{
Debug.LogError("Virtual Button '" + vb.name + "' doesn't " +
"have an Image Target as an ancestor.");
}
else
{
if (it.ImageTargetType == ImageTargetType.USER_DEFINED)
{
Debug.LogError("Virtual Button '" + vb.name + "' cannot be added to a user defined target.");
}
}
}
}
/// <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);
}
void IEditorImageTargetBehaviour.InitializeImageTarget(ImageTarget imageTarget)
{
mTrackable = mImageTarget = imageTarget;
mVirtualButtonBehaviours = new Dictionary <int, VirtualButtonBehaviour>();
// do not change the aspect ratio of user defined targets, these are set by the algorithm internally
if (imageTarget.ImageTargetType == ImageTargetType.PREDEFINED)
{
// Handle any changes to the image target in the scene
// that are not reflected in the config file
Vector2 imgTargetUnitySize = GetSize();
imageTarget.SetSize(imgTargetUnitySize);
}
else // instead, set the aspect of the unity object to the value of the user defined target
{
Vector2 udtSize = imageTarget.GetSize();
// set the size of the target to the value returned from cloud reco:
transform.localScale =
new Vector3(udtSize.x,
udtSize.x,
udtSize.x);
IEditorImageTargetBehaviour editorThis = this;
editorThis.CorrectScale();
editorThis.SetAspectRatio(udtSize.y / udtSize.x);
}
}
private void DrawPredefinedTargetInsprectorUI(IEditorImageTargetBehaviour itb, bool typeChanged)
{
if (typeChanged)
{
UpdateMaterial(itb);
}
if (ConfigDataManager.Instance.NumConfigDataObjects > 1)
{
string[] configDataNames = new string[ConfigDataManager.Instance.NumConfigDataObjects];
ConfigDataManager.Instance.GetConfigDataNames(configDataNames);
int indexFromString = QCARUtilities.GetIndexFromString(itb.DataSetName, configDataNames);
if (indexFromString < 0)
{
indexFromString = 0;
}
int index = EditorGUILayout.Popup("Data Set", indexFromString, configDataNames, new GUILayoutOption[0]);
string dataSetName = configDataNames[index];
ConfigData configData = ConfigDataManager.Instance.GetConfigData(dataSetName);
string[] arrayToFill = new string[configData.NumImageTargets];
configData.CopyImageTargetNames(arrayToFill, 0);
int selectedIndex = QCARUtilities.GetIndexFromString(itb.TrackableName, arrayToFill);
if (selectedIndex < 0)
{
selectedIndex = 0;
}
if (index != indexFromString)
{
selectedIndex = 0;
}
int num5 = EditorGUILayout.Popup("Image Target", selectedIndex, arrayToFill, new GUILayoutOption[0]);
float width = EditorGUILayout.FloatField("Width", itb.GetSize().x, new GUILayoutOption[0]);
if (width != itb.GetSize().x)
{
itb.SetWidth(width);
}
float height = EditorGUILayout.FloatField("Height ", itb.GetSize().y, new GUILayoutOption[0]);
if (height != itb.GetSize().y)
{
itb.SetHeight(height);
}
itb.SetExtendedTracking(EditorGUILayout.Toggle("Extended tracking", itb.ExtendedTracking, new GUILayoutOption[0]));
itb.SetPreserveChildSize(EditorGUILayout.Toggle("Preserve child size", itb.PreserveChildSize, new GUILayoutOption[0]));
if ((arrayToFill.Length > 0) && (((index != indexFromString) || (num5 != selectedIndex)) || typeChanged))
{
ConfigData.ImageTargetData data2;
itb.SetDataSetPath("QCAR/" + configDataNames[index] + ".xml");
string name = arrayToFill[num5];
itb.SetNameForTrackable(name);
configData.GetImageTarget(itb.TrackableName, out data2);
UpdateAspectRatio(itb, data2.size);
UpdateScale(itb, data2.size);
UpdateMaterial(itb);
}
}
else if (GUILayout.Button("No targets defined. Press here for target creation!", new GUILayoutOption[0]))
{
SceneManager.Instance.GoToTargetManagerPage();
}
}
private static void UpdateMesh(IEditorImageTargetBehaviour it)
{
GameObject itObject = it.gameObject;
MeshFilter meshFilter = itObject.GetComponent <MeshFilter>();
if (!meshFilter)
{
meshFilter = itObject.AddComponent <MeshFilter>();
}
Vector3 p0, p1, p2, p3;
if (it.AspectRatio <= 1.0f)
{
p0 = new Vector3(-0.5f, 0, -it.AspectRatio * 0.5f);
p1 = new Vector3(-0.5f, 0, it.AspectRatio * 0.5f);
p2 = new Vector3(0.5f, 0, -it.AspectRatio * 0.5f);
p3 = new Vector3(0.5f, 0, it.AspectRatio * 0.5f);
}
else
{
float aspectRationInv = 1.0f / it.AspectRatio;
p0 = new Vector3(-aspectRationInv * 0.5f, 0, -0.5f);
p1 = new Vector3(-aspectRationInv * 0.5f, 0, 0.5f);
p2 = new Vector3(aspectRationInv * 0.5f, 0, -0.5f);
p3 = new Vector3(aspectRationInv * 0.5f, 0, 0.5f);
}
Mesh mesh = new Mesh();
mesh.vertices = new Vector3[] { p0, p1, p2, p3 };
mesh.triangles = new int[] {
0, 1, 2,
2, 1, 3
};
mesh.normals = new Vector3[mesh.vertices.Length];
mesh.uv = new Vector2[] {
new Vector2(0, 0),
new Vector2(0, 1),
new Vector2(1, 0),
new Vector2(1, 1)
};
mesh.RecalculateNormals();
meshFilter.mesh = mesh;
MeshRenderer meshRenderer = itObject.GetComponent <MeshRenderer>();
if (!meshRenderer)
{
meshRenderer = itObject.AddComponent <MeshRenderer>();
}
// Cleanup assets that have been created temporarily.
EditorUtility.UnloadUnusedAssets();
}
// Assign material and texture to Image Target.
public static void UpdateMaterial(IEditorImageTargetBehaviour it)
{
// Load reference material.
string referenceMaterialPath =
QCARUtilities.GlobalVars.REFERENCE_MATERIAL_PATH;
Material referenceMaterial =
(Material)AssetDatabase.LoadAssetAtPath(referenceMaterialPath,
typeof(Material));
if (referenceMaterial == null)
{
Debug.LogError("Could not find reference material at " +
referenceMaterialPath +
" please reimport Unity package.");
return;
}
// Load texture from texture folder. Textures have per convention the
// same name as Image Targets + "_scaled" as postfix.
string pathToTexture = QCARUtilities.GlobalVars.TARGET_TEXTURES_PATH;
string textureFile = pathToTexture + it.DataSetName + "/" + it.TrackableName + "_scaled";
if (File.Exists(textureFile + ".png"))
textureFile += ".png";
else if (File.Exists(textureFile + ".jpg"))
textureFile += ".jpg";
Texture2D targetTexture =
(Texture2D)AssetDatabase.LoadAssetAtPath(textureFile,
typeof(Texture2D));
if (targetTexture == null)
{
if (it.ImageTargetType == ImageTargetType.USER_DEFINED)
// show the UserDefinedTarget default texture in case it's a user defined target
it.renderer.sharedMaterial = (Material)AssetDatabase.LoadAssetAtPath(QCARUtilities.GlobalVars.UDT_MATERIAL_PATH, typeof(Material));
else if (it.ImageTargetType == ImageTargetType.CLOUD_RECO)
// show the cloud reco default texture in case it's a cloud reco target
it.renderer.sharedMaterial = (Material)AssetDatabase.LoadAssetAtPath(QCARUtilities.GlobalVars.CL_MATERIAL_PATH, typeof(Material));
else
// If the texture is null we simply assign a default material.
it.renderer.sharedMaterial = referenceMaterial;
return;
}
// We create a new material that is based on the reference material but
// also contains a texture.
Material materialForTargetTexture = new Material(referenceMaterial);
materialForTargetTexture.mainTexture = targetTexture;
materialForTargetTexture.name = targetTexture.name + "Material";
materialForTargetTexture.mainTextureScale = new Vector2(1, 1);
it.renderer.sharedMaterial = materialForTargetTexture;
// Cleanup assets that have been created temporarily.
EditorUtility.UnloadUnusedAssets();
}
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);
}
private void DrawCloudRecoTargetInspectorUI(IEditorImageTargetBehaviour itb, bool typeChanged)
{
if (typeChanged)
{
ConfigData.ImageTargetData data = QCARUtilities.CreateDefaultImageTarget();
itb.SetNameForTrackable(string.Empty);
UpdateAspectRatio(itb, data.size);
UpdateMaterial(itb);
}
itb.SetExtendedTracking(EditorGUILayout.Toggle("Extended tracking", itb.ExtendedTracking, new GUILayoutOption[0]));
itb.SetPreserveChildSize(EditorGUILayout.Toggle("Preserve child size", itb.PreserveChildSize, new GUILayoutOption[0]));
}
// Lets the user choose a Image Target from a drop down list. Image Target
// must be defined in the "config.xml" file.
public override void OnInspectorGUI()
{
EditorGUIUtility.LookLikeInspector();
DrawDefaultInspector();
ImageTargetBehaviour itb = (ImageTargetBehaviour)target;
IEditorImageTargetBehaviour editorItb = itb;
if (QCARUtilities.GetPrefabType(itb) == PrefabType.Prefab)
{
GUILayout.Label("You can't choose a target for a prefab.");
}
else
{
ImageTargetType oldType = editorItb.ImageTargetType;
// show dropdown for type selection (predefined TMS target vs. user defined target)
string[] typeNames =
new[] { QCARUtilities.GlobalVars.PREDEFINED_TARGET_DROPDOWN_TEXT,
QCARUtilities.GlobalVars.USER_CREATED_TARGET_DROPDOWN_TEXT,
QCARUtilities.GlobalVars.CLOUD_RECO_DROPDOWN_TEXT };
ImageTargetType[] typeValues =
new [] { ImageTargetType.PREDEFINED,
ImageTargetType.USER_DEFINED,
ImageTargetType.CLOUD_RECO };
editorItb.SetImageTargetType(typeValues[EditorGUILayout.Popup("Type", typeValues.ToList().IndexOf(editorItb.ImageTargetType), typeNames)]);
bool typeChanged = editorItb.ImageTargetType != oldType;
if (editorItb.ImageTargetType == ImageTargetType.PREDEFINED)
{
DrawPredefinedTargetInsprectorUI(itb, typeChanged);
}
else if (editorItb.ImageTargetType == ImageTargetType.USER_DEFINED)
{
DrawUserDefinedTargetInspectorUI(itb, typeChanged);
}
else
{
DrawCloudRecoTargetInspectorUI(itb, typeChanged);
}
}
if (GUI.changed)
{
EditorUtility.SetDirty(itb);
SceneManager.Instance.SceneUpdated();
}
}
public static void UpdateMaterial(IEditorImageTargetBehaviour it)
{
string assetPath = "Assets/Qualcomm Augmented Reality/Materials/DefaultTarget.mat";
Material source = (Material)AssetDatabase.LoadAssetAtPath(assetPath, typeof(Material));
if (source == null)
{
Debug.LogError("Could not find reference material at " + assetPath + " please reimport Unity package.");
}
else
{
string str2 = "Assets/Editor/QCAR/ImageTargetTextures/";
string str3 = str2 + it.DataSetName + "/" + it.TrackableName + "_scaled";
if (File.Exists(str3 + ".png"))
{
str3 = str3 + ".png";
}
else if (File.Exists(str3 + ".jpg"))
{
str3 = str3 + ".jpg";
}
Texture2D textured = (Texture2D)AssetDatabase.LoadAssetAtPath(str3, typeof(Texture2D));
if (textured == null)
{
if (it.ImageTargetType == ImageTargetType.USER_DEFINED)
{
it.renderer.sharedMaterial = (Material)AssetDatabase.LoadAssetAtPath("Assets/Qualcomm Augmented Reality/Materials/UserDefinedTarget.mat", typeof(Material));
}
else if (it.ImageTargetType == ImageTargetType.CLOUD_RECO)
{
it.renderer.sharedMaterial = (Material)AssetDatabase.LoadAssetAtPath("Assets/Qualcomm Augmented Reality/Materials/CloudRecoTarget.mat", typeof(Material));
}
else
{
it.renderer.sharedMaterial = source;
}
}
else
{
Material material2 = new Material(source)
{
mainTexture = textured,
name = textured.name + "Material",
mainTextureScale = new Vector2(1f, 1f)
};
it.renderer.sharedMaterial = material2;
EditorUtility.UnloadUnusedAssets();
}
}
}
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 + "'.");
}
}
}
}
private static void CheckMesh(IEditorImageTargetBehaviour it)
{
GameObject gameObject = it.gameObject;
MeshFilter component = gameObject.GetComponent <MeshFilter>();
if ((component == null) || (component.sharedMesh == null))
{
UpdateMesh(it);
}
MeshRenderer renderer = gameObject.GetComponent <MeshRenderer>();
if (((renderer == null) || (renderer.sharedMaterials.Length == 0)) || (renderer.sharedMaterials[0] == null))
{
UpdateMaterial(it);
}
}
private void DrawUserDefinedTargetInspectorUI(IEditorImageTargetBehaviour itb, bool typeChanged)
{
if (typeChanged)
{
ConfigData.ImageTargetData data = QCARUtilities.CreateDefaultImageTarget();
itb.SetNameForTrackable(string.Empty);
UpdateAspectRatio(itb, data.size);
UpdateMaterial(itb);
}
if (itb.TrackableName.Length > 0x40)
{
EditorGUILayout.HelpBox("Target name must not exceed 64 character limit!", MessageType.Error);
}
itb.SetNameForTrackable(EditorGUILayout.TextField("Target Name", itb.TrackableName, new GUILayoutOption[0]));
itb.SetExtendedTracking(EditorGUILayout.Toggle("Extended tracking", itb.ExtendedTracking, new GUILayoutOption[0]));
itb.SetPreserveChildSize(EditorGUILayout.Toggle("Preserve child size", itb.PreserveChildSize, new GUILayoutOption[0]));
}
private void DrawCloudRecoTargetInspectorUI(IEditorImageTargetBehaviour itb, bool typeChanged)
{
if (typeChanged)
{
ConfigData.ImageTargetData itConfig = QCARUtilities.CreateDefaultImageTarget();
itb.SetNameForTrackable(string.Empty);
// Update the aspect ratio and mesh used for visualisation:
UpdateAspectRatio(itb, itConfig.size);
// Update the material:
UpdateMaterial(itb);
}
// Draw check box to de-/activate "preserve child size" mode.
itb.SetPreserveChildSize(EditorGUILayout.Toggle("Preserve child size", itb.PreserveChildSize));
}
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);
}
private static void UpdateMesh(IEditorImageTargetBehaviour it)
{
Vector3 vector;
Vector3 vector2;
Vector3 vector3;
Vector3 vector4;
GameObject gameObject = it.gameObject;
MeshFilter component = gameObject.GetComponent <MeshFilter>();
if (component == null)
{
component = gameObject.AddComponent <MeshFilter>();
}
if (it.AspectRatio <= 1f)
{
vector = new Vector3(-0.5f, 0f, -it.AspectRatio * 0.5f);
vector2 = new Vector3(-0.5f, 0f, it.AspectRatio * 0.5f);
vector3 = new Vector3(0.5f, 0f, -it.AspectRatio * 0.5f);
vector4 = new Vector3(0.5f, 0f, it.AspectRatio * 0.5f);
}
else
{
float num = 1f / it.AspectRatio;
vector = new Vector3(-num * 0.5f, 0f, -0.5f);
vector2 = new Vector3(-num * 0.5f, 0f, 0.5f);
vector3 = new Vector3(num * 0.5f, 0f, -0.5f);
vector4 = new Vector3(num * 0.5f, 0f, 0.5f);
}
Mesh mesh = new Mesh();
mesh.vertices = new Vector3[] { vector, vector2, vector3, vector4 };
mesh.triangles = new int[] { 0, 1, 2, 2, 1, 3 };
mesh.normals = new Vector3[mesh.vertices.Length];
mesh.uv = new Vector2[] { new Vector2(0f, 0f), new Vector2(0f, 1f), new Vector2(1f, 0f), new Vector2(1f, 1f) };
mesh.RecalculateNormals();
component.mesh = mesh;
if (gameObject.GetComponent <MeshRenderer>() == null)
{
MeshRenderer renderer = gameObject.AddComponent <MeshRenderer>();
}
EditorUtility.UnloadUnusedAssets();
}
// This method checks for duplicate virtual buttons in a given image
// target and prints an error accordingly.
private static void DetectDuplicates(ImageTargetBehaviour it)
{
IEditorImageTargetBehaviour editorIt = it;
VirtualButtonBehaviour[] vbs =
it.GetComponentsInChildren <VirtualButtonBehaviour>();
for (int i = 0; i < vbs.Length; ++i)
{
for (int j = i + 1; j < vbs.Length; ++j)
{
if (vbs[i].VirtualButtonName == vbs[j].VirtualButtonName)
{
Debug.LogError("Duplicate virtual buttons with name '" +
vbs[i].VirtualButtonName + "' detected in " +
"Image Target '" + editorIt.TrackableName + "'.");
}
}
}
}
private static void CheckMesh(IEditorImageTargetBehaviour it)
{
// when copy-pasting image targets between scenes, the mesh and materials of
// the game objects get lost. This checks for them and re-creates them if they are found missing.
GameObject itObject = it.gameObject;
MeshFilter meshFilter = itObject.GetComponent <MeshFilter>();
if (meshFilter == null || meshFilter.sharedMesh == null)
{
UpdateMesh(it);
}
MeshRenderer meshRenderer = itObject.GetComponent <MeshRenderer>();
if (meshRenderer == null || meshRenderer.sharedMaterials.Length == 0 || meshRenderer.sharedMaterials[0] == null)
{
UpdateMaterial(it);
}
}
// Initializes the Image Target when it is drag-dropped into the scene.
public void OnEnable()
{
ImageTargetBehaviour itb = (ImageTargetBehaviour)target;
// We don't want to initialize if this is a prefab.
if (QCARUtilities.GetPrefabType(itb) == PrefabType.Prefab)
{
return;
}
// Make sure the scene and config.xml file are synchronized.
if (!SceneManager.Instance.SceneInitialized)
{
SceneManager.Instance.InitScene();
}
IEditorImageTargetBehaviour editorItb = itb;
// Only setup target if it has not been set up previously.
if (!editorItb.InitializedInEditor && !EditorApplication.isPlaying)
{
ConfigData.ImageTargetData itConfig;
ConfigData dataSetData = ConfigDataManager.Instance.GetConfigData(QCARUtilities.GlobalVars.DEFAULT_DATA_SET_NAME);
dataSetData.GetImageTarget(QCARUtilities.GlobalVars.DEFAULT_TRACKABLE_NAME, out itConfig);
UpdateAspectRatio(itb, itConfig.size);
UpdateScale(itb, itConfig.size);
UpdateMaterial(itb);
editorItb.SetDataSetPath(QCARUtilities.GlobalVars.DEFAULT_DATA_SET_NAME);
editorItb.SetNameForTrackable(QCARUtilities.GlobalVars.DEFAULT_TRACKABLE_NAME);
editorItb.SetInitializedInEditor(true);
}
else if (!EditorApplication.isPlaying)
{
CheckMesh(editorItb);
}
// Cache the current scale of the target:
editorItb.SetPreviousScale(itb.transform.localScale);
}
public static void Validate()
{
ImageTargetAbstractBehaviour[] behaviourArray = (ImageTargetAbstractBehaviour[])UnityEngine.Object.FindObjectsOfType(typeof(ImageTargetAbstractBehaviour));
foreach (ImageTargetAbstractBehaviour behaviour in behaviourArray)
{
DetectDuplicates(behaviour);
}
VirtualButtonAbstractBehaviour[] behaviourArray2 = (VirtualButtonAbstractBehaviour[])UnityEngine.Object.FindObjectsOfType(typeof(VirtualButtonAbstractBehaviour));
foreach (VirtualButtonAbstractBehaviour behaviour2 in behaviourArray2)
{
IEditorImageTargetBehaviour imageTargetBehaviour = behaviour2.GetImageTargetBehaviour();
if (imageTargetBehaviour == null)
{
Debug.LogError("Virtual Button '" + behaviour2.name + "' doesn't have an Image Target as an ancestor.");
}
else if (imageTargetBehaviour.ImageTargetType == ImageTargetType.USER_DEFINED)
{
Debug.LogError("Virtual Button '" + behaviour2.name + "' cannot be added to a user defined target.");
}
}
}
public static void UpdateScale(IEditorImageTargetBehaviour it, Vector2 size)
{
float num = it.GetSize()[0] / size[0];
if (it.AspectRatio <= 1f)
{
it.transform.localScale = new Vector3(size[0], size[0], size[0]);
}
else
{
it.transform.localScale = new Vector3(size[1], size[1], size[1]);
}
if (it.PreserveChildSize)
{
foreach (Transform transform in it.transform)
{
transform.localPosition = new Vector3(transform.localPosition.x * num, transform.localPosition.y * num, transform.localPosition.z * num);
transform.localScale = new Vector3(transform.localScale.x * num, transform.localScale.y * num, transform.localScale.z * num);
}
}
}
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();
}
}
void IEditorImageTargetBehaviour.InitializeImageTarget(ImageTarget imageTarget)
{
base.mTrackable = this.mImageTarget = imageTarget;
this.mVirtualButtonBehaviours = new Dictionary <int, VirtualButtonAbstractBehaviour>();
if (imageTarget.ImageTargetType == ImageTargetType.PREDEFINED)
{
Vector2 size = this.GetSize();
imageTarget.SetSize(size);
}
else
{
Vector2 vector2 = imageTarget.GetSize();
float x = (vector2.x > vector2.y) ? vector2.x : vector2.y;
base.transform.localScale = new Vector3(x, x, x);
IEditorImageTargetBehaviour behaviour = this;
behaviour.CorrectScale();
this.mAspectRatio = vector2.y / vector2.x;
}
if (base.mExtendedTracking)
{
this.mImageTarget.StartExtendedTracking();
}
}
public override void ApplyDataSetAppearance()
{
if (QCARUtilities.GetPrefabType(base.mTarget) != PrefabType.Prefab)
{
ConfigData.ImageTargetData data;
IEditorImageTargetBehaviour mTarget = (ImageTargetAbstractBehaviour)base.mTarget;
if (this.TrackableInDataSet(mTarget.TrackableName, mTarget.DataSetName))
{
ConfigDataManager.Instance.GetConfigData(mTarget.DataSetName).GetImageTarget(mTarget.TrackableName, out data);
}
else if (mTarget.ImageTargetType != ImageTargetType.PREDEFINED)
{
data = QCARUtilities.CreateDefaultImageTarget();
}
else
{
ConfigDataManager.Instance.GetConfigData("--- EMPTY ---").GetImageTarget("--- EMPTY ---", out data);
mTarget.SetDataSetPath("--- EMPTY ---");
mTarget.SetNameForTrackable("--- EMPTY ---");
}
ImageTargetEditor.UpdateAspectRatio(mTarget, data.size);
ImageTargetEditor.UpdateMaterial(mTarget);
}
}
private void DrawUserDefinedTargetInspectorUI(IEditorImageTargetBehaviour itb, bool typeChanged)
{
if (typeChanged)
{
ConfigData.ImageTargetData itConfig = QCARUtilities.CreateDefaultImageTarget();
itb.SetNameForTrackable(string.Empty);
// Update the aspect ratio and mesh used for visualisation:
UpdateAspectRatio(itb, itConfig.size);
// Update the material:
UpdateMaterial(itb);
}
if (itb.TrackableName.Length > 64)
{
EditorGUILayout.HelpBox("Target name must not exceed 64 character limit!", MessageType.Error);
}
itb.SetNameForTrackable(EditorGUILayout.TextField("Target Name", itb.TrackableName));
// Draw check box to de-/activate "preserve child size" mode.
itb.SetPreserveChildSize(EditorGUILayout.Toggle("Preserve child size", itb.PreserveChildSize));
}
private ImageTargetBehaviour CreateImageTargetBehaviour(ImageTarget imageTarget)
{
GameObject imageTargetObject = new GameObject();
ImageTargetBehaviour newITB =
imageTargetObject.AddComponent <ImageTargetBehaviour>();
IEditorImageTargetBehaviour newEditorITB = newITB;
Debug.Log("Creating Image Target with values: " +
"\n ID: " + imageTarget.ID +
"\n Name: " + imageTarget.Name +
"\n Path: " + newEditorITB.DataSetPath +
"\n Size: " + imageTarget.GetSize().x + "x" + imageTarget.GetSize().y);
// Set Image Target attributes.
newEditorITB.SetNameForTrackable(imageTarget.Name);
newEditorITB.SetDataSetPath(newEditorITB.DataSetPath);
newEditorITB.transform.localScale = new Vector3(imageTarget.GetSize().x, 1.0f, imageTarget.GetSize().y);
newEditorITB.CorrectScale();
newEditorITB.SetAspectRatio(imageTarget.GetSize()[1] / imageTarget.GetSize()[0]);
newEditorITB.InitializeImageTarget(imageTarget);
return(newITB);
}
private static void CheckMesh(IEditorImageTargetBehaviour it)
{
// when copy-pasting image targets between scenes, the mesh and materials of
// the game objects get lost. This checks for them and re-creates them if they are found missing.
GameObject itObject = it.gameObject;
MeshFilter meshFilter = itObject.GetComponent<MeshFilter>();
if (meshFilter == null || meshFilter.sharedMesh == null)
{
UpdateMesh(it);
}
MeshRenderer meshRenderer = itObject.GetComponent <MeshRenderer>();
if (meshRenderer == null || meshRenderer.sharedMaterials.Length == 0 || meshRenderer.sharedMaterials[0] == null)
{
UpdateMaterial(it);
}
}
private void DrawUserDefinedTargetInspectorUI(IEditorImageTargetBehaviour itb, bool typeChanged)
{
if (typeChanged)
{
ConfigData.ImageTargetData itConfig = QCARUtilities.CreateDefaultImageTarget();
itb.SetNameForTrackable(string.Empty);
// Update the aspect ratio and mesh used for visualisation:
UpdateAspectRatio(itb, itConfig.size);
// Update the material:
UpdateMaterial(itb);
}
if (itb.TrackableName.Length > 64)
EditorGUILayout.HelpBox("Target name must not exceed 64 character limit!", MessageType.Error);
itb.SetNameForTrackable(EditorGUILayout.TextField("Target Name", itb.TrackableName));
// Draw check box to de-/activate "preserve child size" mode.
itb.SetPreserveChildSize(EditorGUILayout.Toggle("Preserve child size", itb.PreserveChildSize));
}
private void DrawPredefinedTargetInsprectorUI(IEditorImageTargetBehaviour itb, bool typeChanged)
{
if (typeChanged)
UpdateMaterial(itb);
if (ConfigDataManager.Instance.NumConfigDataObjects > 1) //< "> 1" because we ignore the default dataset.
{
// Draw list for choosing a data set.
string[] dataSetList = new string[ConfigDataManager.Instance.NumConfigDataObjects];
ConfigDataManager.Instance.GetConfigDataNames(dataSetList);
int currentDataSetIndex = QCARUtilities.GetIndexFromString(itb.DataSetName, dataSetList);
// If name is not in array we automatically choose default name;
if (currentDataSetIndex < 0)
currentDataSetIndex = 0;
int newDataSetIndex = EditorGUILayout.Popup("Data Set",
currentDataSetIndex,
dataSetList);
string chosenDataSet = dataSetList[newDataSetIndex];
ConfigData dataSetData = ConfigDataManager.Instance.GetConfigData(chosenDataSet);
// Draw list for choosing a Trackable
int targetCount = dataSetData.NumImageTargets;
string[] namesList = new string[targetCount];
dataSetData.CopyImageTargetNames(namesList, 0);
// get the current index
int currentTrackableIndex = QCARUtilities.GetIndexFromString(itb.TrackableName, namesList);
// If name is not in array we automatically choose default name;
if (currentTrackableIndex < 0)
currentTrackableIndex = 0;
// Reset name index if a new data set has been chosen.
if (newDataSetIndex != currentDataSetIndex)
{
currentTrackableIndex = 0;
}
int newTrackableIndex = EditorGUILayout.Popup("Image Target",
currentTrackableIndex,
namesList);
// Draw check box to de-/activate "preserve child size" mode.
itb.SetPreserveChildSize(EditorGUILayout.Toggle("Preserve child size", itb.PreserveChildSize));
if (namesList.Length > 0)
{
if (newDataSetIndex != currentDataSetIndex || newTrackableIndex != currentTrackableIndex || typeChanged)
{
itb.SetDataSetPath("QCAR/" + dataSetList[newDataSetIndex] + ".xml");
string selectedString = namesList[newTrackableIndex];
ConfigData.ImageTargetData itConfig;
itb.SetNameForTrackable(selectedString);
dataSetData.GetImageTarget(itb.TrackableName, out itConfig);
// Update the aspect ratio and mesh used for visualisation:
UpdateAspectRatio(itb, itConfig.size);
// Update the material:
UpdateMaterial(itb);
}
}
}
else
{
if (GUILayout.Button("No targets defined. Press here for target " +
"creation!"))
{
SceneManager.Instance.GoToARPage();
}
}
}
// Recalculates the aspect ratio of the Image Target from a size vector.
// Automatically updates mesh as well.
public static void UpdateAspectRatio(IEditorImageTargetBehaviour it, Vector2 size)
{
it.SetAspectRatio(size[1] / size[0]);
UpdateMesh(it);
}
private void DrawCloudRecoTargetInspectorUI(IEditorImageTargetBehaviour itb, bool typeChanged)
{
if (typeChanged)
{
ConfigData.ImageTargetData itConfig = QCARUtilities.CreateDefaultImageTarget();
itb.SetNameForTrackable(string.Empty);
// Update the aspect ratio and mesh used for visualisation:
UpdateAspectRatio(itb, itConfig.size);
// Update the material:
UpdateMaterial(itb);
}
// Draw check box to de-/activate "preserve child size" mode.
itb.SetPreserveChildSize(EditorGUILayout.Toggle("Preserve child size", itb.PreserveChildSize));
}
private static void UpdateMesh(IEditorImageTargetBehaviour it)
{
GameObject itObject = it.gameObject;
MeshFilter meshFilter = itObject.GetComponent<MeshFilter>();
if (!meshFilter)
{
meshFilter = itObject.AddComponent<MeshFilter>();
}
Vector3 p0, p1, p2, p3;
if (it.AspectRatio <= 1.0f)
{
p0 = new Vector3(-0.5f, 0, -it.AspectRatio * 0.5f);
p1 = new Vector3(-0.5f, 0, it.AspectRatio * 0.5f);
p2 = new Vector3(0.5f, 0, -it.AspectRatio * 0.5f);
p3 = new Vector3(0.5f, 0, it.AspectRatio * 0.5f);
}
else
{
float aspectRationInv = 1.0f / it.AspectRatio;
p0 = new Vector3(-aspectRationInv * 0.5f, 0, -0.5f);
p1 = new Vector3(-aspectRationInv * 0.5f, 0, 0.5f);
p2 = new Vector3(aspectRationInv * 0.5f, 0, -0.5f);
p3 = new Vector3(aspectRationInv * 0.5f, 0, 0.5f);
}
Mesh mesh = new Mesh();
mesh.vertices = new Vector3[] { p0, p1, p2, p3 };
mesh.triangles = new int[] {
0,1,2,
2,1,3
};
mesh.normals = new Vector3[mesh.vertices.Length];
mesh.uv = new Vector2[]{
new Vector2(0,0),
new Vector2(0,1),
new Vector2(1,0),
new Vector2(1,1)
};
mesh.RecalculateNormals();
meshFilter.mesh = mesh;
MeshRenderer meshRenderer = itObject.GetComponent<MeshRenderer>();
if (!meshRenderer)
{
meshRenderer = itObject.AddComponent<MeshRenderer>();
}
// Cleanup assets that have been created temporarily.
EditorUtility.UnloadUnusedAssets();
}
// Updates the scale values in the transform component from a given size.
public static void UpdateScale(IEditorImageTargetBehaviour it, Vector2 size)
{
// Update the scale:
float childScaleFactor = it.GetSize()[0] / size[0];
if (it.AspectRatio <= 1.0f)
{
it.transform.localScale = new Vector3(size[0], size[0], size[0]);
}
else
{
it.transform.localScale = new Vector3(size[1], size[1], size[1]);
}
// Check if 3D content should keep its size or if it should be scaled
// with the target.
if (it.PreserveChildSize)
{
foreach (Transform child in it.transform)
{
child.localPosition =
new Vector3(child.localPosition.x * childScaleFactor,
child.localPosition.y * childScaleFactor,
child.localPosition.z * childScaleFactor);
child.localScale =
new Vector3(child.localScale.x * childScaleFactor,
child.localScale.y * childScaleFactor,
child.localScale.z * childScaleFactor);
}
}
}
