/// <summary>
/// UI to add a new image marker to the marker library
/// </summary>
/// <param name="markerLibrary">The marker library currently being edited</param>
static void DrawAddImageMarkerButton(MarsMarkerLibrary markerLibrary)
{
const int pickerID = 0xC0FFEE;
const string objectSelectorClosed = "ObjectSelectorClosed";
if (GUILayout.Button(styles.AddImageMarkerButton, MarsEditorGUI.InternalEditorStyles.FooterButtonStyle,
GUILayout.Width(Styles.AddRemoveButtonSize), GUILayout.Height(Styles.AddRemoveButtonSize)))
{
EditorGUIUtility.ShowObjectPicker <Texture2D>(null, false, "", pickerID);
s_FlagSelectingMarker = true;
}
if (Event.current.commandName == objectSelectorClosed &&
EditorGUIUtility.GetObjectPickerControlID() == pickerID && s_FlagSelectingMarker)
{
var selectedTexture = EditorGUIUtility.GetObjectPickerObject() as Texture2D;
const string addEmptyImage = "Add an empty image marker";
Undo.RecordObject(markerLibrary, addEmptyImage);
markerLibrary.CreateAndAdd();
markerLibrary.SetGuid(markerLibrary.Count - 1, Guid.NewGuid());
markerLibrary.SetTexture(markerLibrary.Count - 1, selectedTexture);
EditorUtility.SetDirty(markerLibrary);
markerLibrary.SaveMarkerLibrary();
s_FlagSelectingMarker = false;
}
}
static void ProcessDragAndDropTexturesToMarkerConditionInspector(Event currentEvent,
MarsMarkerLibrary currentMarkerLib)
{
if (currentEvent.type == EventType.DragUpdated)
{
DragAndDrop.visualMode = DragAndDropVisualMode.Copy;
currentEvent.Use();
}
else if (currentEvent.type == EventType.DragPerform)
{
Undo.RecordObject(currentMarkerLib, "Drag images to marker library");
for (var i = 0; i < DragAndDrop.objectReferences.Length; i++)
{
var draggedTexture = DragAndDrop.objectReferences[i] as Texture2D;
if (draggedTexture != null)
{
currentMarkerLib.CreateAndAdd();
EditorUtility.SetDirty(currentMarkerLib);
currentMarkerLib.SaveMarkerLibrary();
currentMarkerLib.SetGuid(currentMarkerLib.Count - 1, Guid.NewGuid());
currentMarkerLib.SetTexture(currentMarkerLib.Count - 1, draggedTexture);
}
}
currentEvent.Use();
}
}
void UpdateMarkerLibraryData(MarsMarkerLibrary markerLibrary, string markerGuidValue)
{
const string markersProp = "m_Markers";
if (m_CurrentMarkerIndex != ImageMarkerEditorUtils.UnselectedMarkerIndex &&
m_CurrentMarkerIndex < markerLibrary.Count &&
markerLibrary[m_CurrentMarkerIndex].MarkerId.ToString() == markerGuidValue &&
m_MarkerLibrary == markerLibrary)
{
return;
}
m_CurrentMarkerIndex = ImageMarkerEditorUtils.CurrentSelectedImageMarkerIndex(markerLibrary, markerGuidValue);
if (m_MarkerLibrary != markerLibrary)
{
m_MarkerLibrarySerializedObject = new SerializedObject(markerLibrary);
m_MarkerProperty = m_MarkerLibrarySerializedObject.FindProperty(markersProp);
m_MarkerLibrary = markerLibrary;
}
if (m_CurrentMarkerIndex != ImageMarkerEditorUtils.UnselectedMarkerIndex)
{
m_SizeOptionIndex = MarkerConstants.GetSelectedMarsMarkerSizeOption(markerLibrary[m_CurrentMarkerIndex].Size);
m_MarkerDefinitionProperty = m_MarkerProperty.GetArrayElementAtIndex(m_CurrentMarkerIndex);
}
}
/// <summary>
/// Draw the Marker Definition Selector GUI
/// </summary>
/// <param name="markerLibrary"></param>
/// <param name="markerGuidValue">The guid string value of the marker id</param>
/// <returns>Guid of the selected marker</returns>
public string DrawSelectorGUI(MarsMarkerLibrary markerLibrary, string markerGuidValue)
{
UpdateMarkerLibraryData(markerLibrary, markerGuidValue);
using (var check = new EditorGUI.ChangeCheckScope())
{
var selectionIndex = ImageMarkerEditorUtils.DrawImageMarkerLibraryInspector(ref m_ImageBrowserScrollPos,
markerLibrary, m_CurrentMarkerIndex);
if (m_CurrentMarkerIndex == ImageMarkerEditorUtils.UnselectedMarkerIndex)
{
EditorGUILayout.HelpBox(k_CurrentMarkerGuidDoesntMatchCurrentLibrary, MessageType.Info);
}
else
{
m_SizeOptionIndex = ImageMarkerEditorUtils.DrawImageMarkerInfoContentsAtIndex(m_MarkerDefinitionProperty,
m_SizeOptionIndex);
}
DrawGuid(markerGuidValue);
if (check.changed)
{
m_MarkerLibrarySerializedObject.ApplyModifiedProperties();
UpdateMarkerLibrarySerializedObject();
}
return(selectionIndex != ImageMarkerEditorUtils.UnselectedMarkerIndex ?
markerLibrary[selectionIndex].MarkerId.ToString() : markerGuidValue);
}
}
void SetMarkerSizeToTransformScale(MarsMarkerLibrary markerLib, int markerIndex)
{
var transformScale = m_SynthesizedMarkerId.transform.localScale;
if (m_LastSyncedTransformScale == transformScale)
{
return;
}
if (markerLib != null && markerIndex != ImageMarkerEditorUtils.UnselectedMarkerIndex)
{
var correctedScale = new Vector3(
transformScale.x > MarkerConstants.MinimumPhysicalMarkerSizeWidthInMeters ?
transformScale.x :
MarkerConstants.MinimumPhysicalMarkerSizeWidthInMeters,
transformScale.y > MarkerConstants.MinimumPhysicalMarkerSizeWidthInMeters ?
transformScale.y :
MarkerConstants.MinimumPhysicalMarkerSizeWidthInMeters,
transformScale.z > MarkerConstants.MinimumPhysicalMarkerSizeHeightInMeters ?
transformScale.z :
MarkerConstants.MinimumPhysicalMarkerSizeHeightInMeters);
m_SynthesizedMarkerId.transform.localScale = correctedScale;
markerLib.SetSize(markerIndex, new Vector2(correctedScale.x, correctedScale.z));
m_MarkerDefinitionSelectorDrawer.UpdateMarkerLibrarySerializedObject();
}
m_LastSyncedTransformScale = transformScale;
}
static bool ContentsSync(MarsMarkerLibrary marsMarkerLibrary, XRReferenceImageLibrary xrReferenceImageLibrary)
{
var needsSave = false;
// Find all changes and synchronize
var referenceImages = new Dictionary <Guid, XRReferenceImage>();
foreach (var xrRefImage in xrReferenceImageLibrary)
{
referenceImages.Add(xrRefImage.guid, xrRefImage);
}
var markersToAdd = new List <MarsMarkerDefinition>();
var markersToUpdateDictionary = new Dictionary <MarsMarkerDefinition, XRReferenceImage>();
foreach (var marsDefinition in marsMarkerLibrary)
{
if (referenceImages.ContainsKey(marsDefinition.MarkerId))
{
var refImage = referenceImages[marsDefinition.MarkerId];
if (refImage.name != marsDefinition.Label || refImage.specifySize != marsDefinition.SpecifySize ||
refImage.size != marsDefinition.Size || refImage.texture != marsDefinition.Texture)
{
markersToUpdateDictionary.Add(marsDefinition, refImage);
needsSave = true;
}
referenceImages.Remove(marsDefinition.MarkerId);
}
else
{
markersToAdd.Add(marsDefinition);
needsSave = true;
}
}
// Whatever is left in referenceImages needs to be deleted, since none of the marker definitions match
needsSave = needsSave || referenceImages.Count > 0;
foreach (var refImageEntry in referenceImages)
{
var index = xrReferenceImageLibrary.indexOf(refImageEntry.Value);
xrReferenceImageLibrary.RemoveAt(index);
}
foreach (var marsMarkerDefinition in markersToAdd)
{
var refImage = AddRefImageFromMarker(xrReferenceImageLibrary, marsMarkerDefinition);
marsMarkerLibrary.SetGuid(marsMarkerLibrary.IndexOf(marsMarkerDefinition), refImage.guid);
}
foreach (var dictEntry in markersToUpdateDictionary)
{
var index = xrReferenceImageLibrary.indexOf(dictEntry.Value);
UpdateRefImage(xrReferenceImageLibrary, index, dictEntry.Key);
}
return(needsSave);
}
public void Add(MarsMarkerLibrary marsLibrary, XRReferenceImageLibrary xrLibrary)
{
//Remove from dictionary to clear out wrapper objects for destroyed assets
MarsToXRLibraryMap.Remove(marsLibrary);
MarsToXRLibraryMap[marsLibrary] = xrLibrary;
m_XRToMarsLibraryMap.Remove(xrLibrary);
m_XRToMarsLibraryMap[xrLibrary] = marsLibrary;
#if UNITY_EDITOR
EditorUtility.SetDirty(this);
#endif
}
public void Remove(MarsMarkerLibrary marsLibrary)
{
if (MarsToXRLibraryMap.TryGetValue(marsLibrary, out var xrLibrary))
{
MarsToXRLibraryMap.Remove(marsLibrary);
m_XRToMarsLibraryMap.Remove(xrLibrary);
#if UNITY_EDITOR
EditorUtility.SetDirty(this);
#endif
}
}
static void HandleAssetDelete(MarsMarkerLibrary markerLibrary, out string deletedPath)
{
if (MarkerProviderSettings.instance.TryFind(markerLibrary, out var xrReferenceImageLibrary))
{
var settings = MarkerProviderSettings.instance;
settings.Remove(markerLibrary);
deletedPath = AssetDatabase.GetAssetPath(xrReferenceImageLibrary);
AssetDatabase.DeleteAsset(deletedPath);
k_DeletedLibraries.Add(xrReferenceImageLibrary);
return;
}
deletedPath = null;
}
static void DrawTopImageMarkerInspectorBox(Rect imageMarkerPos, float verticalBoxOffset,
MarsMarkerLibrary markerLibrary)
{
var topImageMarkerBoxRect = new Rect(imageMarkerPos.x, imageMarkerPos.y - verticalBoxOffset,
imageMarkerPos.width, verticalBoxOffset);
GUI.Box(topImageMarkerBoxRect, styles.TopMarkerLibraryContent, MarsEditorGUI.Styles.TopMarkerLibraryStyle);
var boxX = topImageMarkerBoxRect.x + GUI.skin.box.CalcSize(styles.TopMarkerLibraryContent).x;
if (GUI.Button(new Rect(boxX, topImageMarkerBoxRect.y + Styles.offsetSelectLoadedLibButton,
Styles.selectLoadedLibButtonWidth, Styles.selectLoadedLibButtonHeight), styles.SelectLoadedImageMarkerLibrary))
{
Selection.activeObject = markerLibrary;
}
}
/// <summary>
/// Find the current selected image marker index from the serializable guid string value.
/// </summary>
/// <param name="markerLibrary">The marker library currently in use.</param>
/// <param name="serializableGuidStringValue">The string value of the serializable guid for the image marker.</param>
/// <returns>Returns current selected image marker. If none exists the <c>UnselectedMarkerIndex</c> is returned.</returns>
public static int CurrentSelectedImageMarkerIndex(MarsMarkerLibrary markerLibrary, string serializableGuidStringValue)
{
if (markerLibrary == null)
{
return(UnselectedMarkerIndex);
}
for (var i = 0; i < markerLibrary.Count; i++)
{
if (serializableGuidStringValue == markerLibrary[i].MarkerId.ToString())
{
return(i);
}
}
return(UnselectedMarkerIndex);
}
static void HandleAssetSave(MarsMarkerLibrary marsMarkerLibrary)
{
bool needsSave;
if (MarkerProviderSettings.instance.TryFind(marsMarkerLibrary, out var xrReferenceImageLibrary))
{
// Find what markers need to added, removed or updated in this library
needsSave = ContentsSync(marsMarkerLibrary, xrReferenceImageLibrary);
}
else
{
xrReferenceImageLibrary = CreateARFoundationMarkerLibrary(marsMarkerLibrary);
needsSave = true;
}
if (needsSave)
{
EditorUtility.SetDirty(MarkerProviderSettings.instance);
EditorUtility.SetDirty(xrReferenceImageLibrary);
}
}
/// <summary>
/// UI to remove the currently selected image marker from the library
/// </summary>
/// <param name="selectedImageMarkerIndex">The index of the selected image marker in the marker library.</param>
/// <param name="markerLibrary">The marker library currently being edited</param>
/// <returns><c>True</c> if image was removed</returns>
static bool DrawRemoveImageMarkerButton(int selectedImageMarkerIndex, MarsMarkerLibrary markerLibrary)
{
using (new EditorGUI.DisabledScope(markerLibrary.Count <= 0 ||
selectedImageMarkerIndex == UnselectedMarkerIndex))
{
if (GUILayout.Button(styles.RemoveImageMarkerButton, MarsEditorGUI.InternalEditorStyles.FooterButtonStyle,
GUILayout.Width(Styles.AddRemoveButtonSize), GUILayout.Height(Styles.AddRemoveButtonSize)))
{
const string removeSelectedImage = "Remove selected image marker";
Undo.RecordObject(markerLibrary, removeSelectedImage);
markerLibrary.RemoveAt(selectedImageMarkerIndex);
EditorUtility.SetDirty(markerLibrary);
markerLibrary.SaveMarkerLibrary();
return(true);
}
}
return(false);
}
static XRReferenceImageLibrary CreateARFoundationMarkerLibrary(MarsMarkerLibrary markerLibrary)
{
var xrReferenceImageLibrary = ScriptableObject.CreateInstance <XRReferenceImageLibrary>();
var count = markerLibrary.Count;
for (var i = 0; i < count; i++)
{
var definition = markerLibrary[i];
var refImage = AddRefImageFromMarker(xrReferenceImageLibrary, definition);
markerLibrary.SetGuid(i, refImage.guid);
}
var pathName = AssetDatabase.GetAssetPath(markerLibrary);
xrReferenceImageLibrary.name = string.Format(MarkerProviderSettings.ARFLibrarySuffixFormat, Path.GetFileNameWithoutExtension(pathName));
xrReferenceImageLibrary.hideFlags = HideFlags.NotEditable;
var filename = xrReferenceImageLibrary.name + Path.GetExtension(pathName);
var dirName = Path.GetDirectoryName(pathName);
var assetPathName = Path.Combine(dirName, filename);
AssetDatabase.CreateAsset(xrReferenceImageLibrary, assetPathName);
MarkerProviderSettings.instance.Add(markerLibrary, xrReferenceImageLibrary);
return(xrReferenceImageLibrary);
}
public void UpdateMarkerDataFromLibraries()
{
m_MarkerIDToLibrary.Clear();
m_GUIContentIDToMarkerID.Clear();
m_MarkerIDToGUIContentID.Clear();
m_MarkerLibraries = Resources.FindObjectsOfTypeAll(typeof(MarsMarkerLibrary)) as MarsMarkerLibrary[];
if (m_MarkerLibraries == null || m_MarkerLibraries.Length == 0)
{
return;
}
MarsMarkerLibrary activeLibrary = null;
var marsSession = MARSSession.Instance;
if (marsSession != null && marsSession.MarkerLibrary != null)
{
activeLibrary = marsSession.MarkerLibrary;
}
var activeFound = false;
foreach (var markerLibrary in m_MarkerLibraries)
{
if (markerLibrary == null)
{
continue;
}
var isActive = activeLibrary == markerLibrary;
if (isActive)
{
m_MarkerDefinitionsContent = new GUIContent[markerLibrary.Count + 1];
m_MarkerDefinitionsContent[0] = k_SelectFromActiveLibrary;
activeFound = true;
}
for (var i = 0; i < markerLibrary.Count; i++)
{
var markerDefinition = markerLibrary[i];
m_MarkerIDToLibrary[markerDefinition.MarkerId] = markerLibrary;
if (!isActive)
{
continue;
}
m_MarkerDefinitionsContent[i + 1] = new GUIContent(markerDefinition.Label, markerDefinition.Texture,
markerDefinition.Texture == null ?
$"Marker Definition with Marker ID {markerDefinition.MarkerId}" :
$"Marker Definition with texture {AssetDatabase.GetAssetPath(markerDefinition.Texture)}");
m_GUIContentIDToMarkerID[i + 1] = markerDefinition.MarkerId;
m_MarkerIDToGUIContentID[markerDefinition.MarkerId] = i + 1;
}
}
if (!activeFound)
{
m_MarkerDefinitionsContent = new GUIContent[1];
m_MarkerDefinitionsContent[0] = k_SelectFromActiveLibrary;
}
}
public bool TryFind(XRReferenceImageLibrary xrLibrary, out MarsMarkerLibrary marsLibrary)
{
return(m_XRToMarsLibraryMap.TryGetValue(xrLibrary, out marsLibrary) && marsLibrary != null);
}
public bool TryFind(MarsMarkerLibrary activeMarsLibrary, out XRReferenceImageLibrary xrReferenceImageLibrary)
{
return(MarsToXRLibraryMap.TryGetValue(activeMarsLibrary, out xrReferenceImageLibrary) && xrReferenceImageLibrary != null);
}
/// <summary>
/// Draws an inspector that displays the marker library contents
/// and allows for selection of one of the markers in the library.
/// </summary>
/// <param name="scrollPos">The scroll position of the view showing the marker library</param>
/// <param name="markerLibrary">The marker library currently being edited</param>
/// <param name="selectedImageMarkerIndex">The index of the selected image marker in the marker library.</param>
/// <returns>Current selected image marker index.</returns>
public static int DrawImageMarkerLibraryInspector(ref Vector2 scrollPos, MarsMarkerLibrary markerLibrary,
int selectedImageMarkerIndex)
{
var imageMarkerInspectorWidth = EditorGUIUtility.currentViewWidth - Styles.EdgeSubtraction;
GUILayout.Box(string.Empty, GUILayout.Height(Styles.ImageBrowserHeight),
GUILayout.Width(imageMarkerInspectorWidth));
var scrollAreaPosRect = GUILayoutUtility.GetLastRect();
// +4 space to fit buttons on top if img marker lib box
var verticalBoxOffset = EditorGUIUtility.singleLineHeight + 4;
scrollAreaPosRect = new Rect(scrollAreaPosRect.x, scrollAreaPosRect.y + verticalBoxOffset,
scrollAreaPosRect.width - 1, scrollAreaPosRect.height - verticalBoxOffset - 1); // -1 to see box edges.
var texturesToPlaceHorizontally = ((int)scrollAreaPosRect.width - Styles.EdgeSubtraction
+ Styles.SpaceBetweenImagesHorizontal * 0.5f)
/ (Styles.ImageMarkersSize + Styles.SpaceBetweenImagesHorizontal);
var texturesToPlaceVertically = Mathf.CeilToInt(markerLibrary.Count / texturesToPlaceHorizontally);
var scrollViewHeight = texturesToPlaceVertically * (Styles.ImageMarkersSize
+ Styles.SpaceBetweenImagesHorizontal + EditorGUIUtility.singleLineHeight);
var scrollAreaRect = new Rect(0, verticalBoxOffset,
scrollAreaPosRect.width - Styles.EdgeSubtraction,
scrollViewHeight + verticalBoxOffset - EditorGUIUtility.singleLineHeight);
var offsetX = (((scrollAreaRect.width + Styles.SpaceBetweenImagesHorizontal * 0.5f)
/ (Styles.ImageMarkersSize + Styles.SpaceBetweenImagesHorizontal)) / texturesToPlaceHorizontally) - 1;
DrawTopImageMarkerInspectorBox(scrollAreaPosRect, verticalBoxOffset, markerLibrary);
using (var scrollScope = new GUI.ScrollViewScope(scrollAreaPosRect, scrollPos,
scrollAreaRect, false, true))
{
scrollPos = scrollScope.scrollPosition;
var currentEvent = Event.current;
var counter = 0;
for (var j = 0; j < texturesToPlaceVertically; j++)
{
for (var i = 0; i < texturesToPlaceHorizontally; i++)
{
var xPos = (Styles.SpaceBetweenImagesHorizontal + i *
(Styles.ImageMarkersSize + Styles.SpaceBetweenImagesHorizontal))
+ (offsetX * scrollAreaRect.width * 0.5f);
var yPos = EditorGUIUtility.singleLineHeight
+ (Styles.SpaceBetweenImagesVertical * 0.5f + j
* (Styles.ImageMarkersSize + Styles.SpaceBetweenImagesVertical));
if (counter < markerLibrary.Count)
{
var isActive = counter == selectedImageMarkerIndex;
var markerDefinition = markerLibrary[counter];
if (DrawImageMarker(xPos, yPos, isActive, markerDefinition))
{
selectedImageMarkerIndex = counter;
if (markerLibrary[counter].MarkerId == Guid.Empty)
{
Debug.LogError("Marker library should be rebuilt since it contains empty guid.");
}
}
}
counter++;
}
}
// Process here since we don't care if user drag/drops somewhere outside of img marker library box
ProcessDragAndDropTexturesToMarkerConditionInspector(
currentEvent,
markerLibrary);
}
using (new EditorGUILayout.HorizontalScope())
{
GUILayout.Space(imageMarkerInspectorWidth - Styles.AddRemoveButtonSize * 2);
DrawAddImageMarkerButton(markerLibrary);
if (DrawRemoveImageMarkerButton(selectedImageMarkerIndex, markerLibrary))
{
selectedImageMarkerIndex = UnselectedMarkerIndex;
}
}
return(selectedImageMarkerIndex);
}
