IntPtr CreateImageDatabase(XRReferenceImageLibrary library)
{
if (!Api.AtLeast11_3())
{
throw new NotSupportedException($"Image libraries require iOS 11.3 or newer.");
}
if (library == null)
{
return(Init());
}
using var managedReferenceImages = library.ToNativeArray(Allocator.Temp);
using var bundle = library.GetNSBundle();
if (bundle == null)
{
throw new InvalidOperationException($"Could not create reference image library '{library.name}'. Unable to create resource bundle.");
}
using var groupName = library.GetARResourceGroupName();
using var referenceImages = ARReferenceImage.GetReferenceImagesInGroupNamed(groupName, bundle);
if (referenceImages.Count != managedReferenceImages.Length)
{
throw new InvalidOperationException($"The number of images in the {nameof(XRReferenceImageLibrary)} named '{library.name}' ({library.count}) does nat match the number of images in the native reference image data ({referenceImages.Count}). The {nameof(XRReferenceImageLibrary)} may need to be re-exported for iOS.");
}
return(InitWithImages(referenceImages.AsIntPtr(), managedReferenceImages.AsNativeView()));
}
public static byte[] BuildDb(XRReferenceImageLibrary library)
{
var tempDirectory = Path.Combine(Path.GetTempPath(), GetTempFileNameWithoutExtension());
try
{
Directory.CreateDirectory(tempDirectory);
var imageListPath = library.ToInputImageListPath(tempDirectory);
var dbPath = Path.Combine(tempDirectory, $"{GetTempFileNameWithoutExtension()}.imgdb");
var(stdOut, stdErr, exitCode) = BuildDb(imageListPath, dbPath);
if (exitCode != 0)
{
throw new BuildDatabaseFailedException(exitCode, stdErr);
}
if (!File.Exists(dbPath))
{
throw new EmptyDatabaseException(stdOut, stdErr);
}
return(File.ReadAllBytes(dbPath));
}
finally
{
if (Directory.Exists(tempDirectory))
{
Directory.Delete(tempDirectory, true);
}
}
}
static void ClearReferenceImageLibraryDataStores()
{
foreach (var library in XRReferenceImageLibrary.All())
{
library.ClearDataStore();
}
}
public void GenerateLibFromSceneSetting()
{
NYImageTracker[] trackers = GameObject.FindObjectsOfType <NYImageTracker>();
Transform[] objs = new Transform[trackers.Length];
XRReferenceImageLibrary newLib = ScriptableObject.CreateInstance <XRReferenceImageLibrary>();
string debugText = "Found " + trackers.Length + " Trackers in Scene:\n";
for (int i = 0; i < trackers.Length; i++)
{
debugText += " " + trackers[i].gameObject.name + "\n";
objs[i] = trackers[i].transform;
XRReferenceImageLibraryExtensions.Add(newLib);
XRReferenceImageLibraryExtensions.SetName(newLib, i, trackers[i].name);
XRReferenceImageLibraryExtensions.SetTexture(newLib, i, trackers[i].trackerImage, false);
XRReferenceImageLibraryExtensions.SetSpecifySize(newLib, i, true);
XRReferenceImageLibraryExtensions.SetSize(newLib, i, trackers[i].physicalSize);
}
string targetPath = Resources.Load <ARFoundationHelperSettings>("HelperSettings").GeneratedLibrarySavePath;
AssetDatabase.CreateAsset(newLib, targetPath + "generated-lib.asset");
((NYImageTrackerManager)target).targetLib = newLib;
((NYImageTrackerManager)target).trackerObjs = objs;
Debug.Log(debugText);
}
static void UpdateRefImage(XRReferenceImageLibrary xrReferenceImageLibrary, int index, MarsMarkerDefinition marsMarkerDefinition)
{
xrReferenceImageLibrary.SetName(index, marsMarkerDefinition.Label);
xrReferenceImageLibrary.SetSpecifySize(index, marsMarkerDefinition.SpecifySize);
xrReferenceImageLibrary.SetSize(index, marsMarkerDefinition.Size);
xrReferenceImageLibrary.SetTexture(index, marsMarkerDefinition.Texture, true);
}
public static unsafe NSBundle GetNSBundle(this XRReferenceImageLibrary library)
{
// If no data exists in the XRReferenceImageLibrary, then try to look it up in the main bundle
if (!library.dataStore.TryGetValue(ARKitPackageInfo.identifier, out var assetCatalogData))
{
var mainBundle = NSBundle.mainBundle;
NSObject.Retain(mainBundle);
return(mainBundle);
}
fixed(void *data = assetCatalogData)
{
using var mainBundleIdentifier = NSBundle.mainBundle.bundleIdentifier;
using var bundleIdentifier = new NSMutableString(mainBundleIdentifier);
using var uuid = library.guid.ToNSString();
bundleIdentifier.Append(uuid);
return(new NSBundle(bundleIdentifier, new NativeView
{
data = data,
count = assetCatalogData.Length
}));
}
}
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);
}
unsafe void DeserializeImageDatabaseFile(XRReferenceImageLibrary serializedLibrary)
{
var libraryPath = MagicLeapImageTrackingSubsystem.GetDatabaseFilePathFromLibrary(serializedLibrary);
if (!File.Exists(libraryPath))
{
throw new ArgumentException($"Serialized Image Tracking Library at '{libraryPath}' doesn't exist.");
}
var bytes = File.ReadAllBytes(libraryPath);
if (bytes.Length < sizeof(ulong))
{
throw new ArgumentException($"Serialized Image Tracking Library at '{libraryPath}' has no image data within it.");
}
var magicBytes = BitConverter.ToUInt64(bytes, 0);
var byteOffset = sizeof(ulong);
if (magicBytes != kMagicBytes)
{
throw new ArgumentException($"Serialized Image Tracking Library at '{libraryPath}' is not a valid image database file.");
}
for (int i = 0; i < serializedLibrary.count; ++i)
{
var referenceImage = serializedLibrary[i];
var imageHandle = MagicLeapImageTrackingSubsystem.Native.InvalidHandle;
var widthInPixels = BitConverter.ToInt32(bytes, byteOffset);
byteOffset += sizeof(int);
var heightInPixels = BitConverter.ToInt32(bytes, byteOffset);
byteOffset += sizeof(int);
// Retain in case we destroy before the images have been processed
RcoApi.Retain(m_NativePtr);
RcoApi.Retain(m_NativeProviderPtr);
fixed(byte *texturePtr = &bytes[byteOffset])
{
var grayscaleImage = new NativeArray <byte>(widthInPixels * heightInPixels, Allocator.Persistent);
NativeArray <byte> .Copy(bytes, byteOffset, grayscaleImage, 0, widthInPixels *heightInPixels);
new AddImageJob
{
nativeProvider = m_NativeProviderPtr,
database = m_NativePtr,
managedReferenceImage = new ManagedReferenceImage(referenceImage),
grayscaleImage = grayscaleImage,
width = widthInPixels,
height = heightInPixels,
name = new NativeArray <byte>(Encoding.UTF8.GetBytes(referenceImage.name + "\0"), Allocator.Persistent)
}.Schedule(m_CreateAssociatedNativeTrackerJobHandle);
}
byteOffset += widthInPixels * heightInPixels;
}
}
/// <summary>
/// Associate binary data with a string key.
/// </summary>
/// <remarks>
/// Providers use this to associate provider-specific data with the library. During Player Build (in an
/// [IPreprocessBuildWithReport.OnPreprocessBuild](xref:UnityEditor.Build.IPreprocessBuildWithReport.OnPreprocessBuild(UnityEditor.Build.Reporting.BuildReport))
/// callback), the data store is first cleared. Each enabled provider then has an opportunity to add one or more
/// entries for itself.
///
/// Providers can use this to store a serialized version of the image library specific to that provider.
/// Retrieve data with <see cref="UnityEngine.XR.ARSubsystems.XRReferenceImageLibrary.dataStore"/>.
/// </remarks>
/// <param name="library">The <see cref="UnityEngine.XR.ARSubsystems.XRReferenceImageLibrary"/> being extended.</param>
/// <param name="key">The key which can be used to later retrieve <paramref name="data"/>.</param>
/// <param name="data">The data to associate with <paramref name="key"/>.</param>
/// <exception cref="System.ArgumentNullException">Thrown if <paramref name="key"/> is `null`.</exception>
public static void SetDataForKey(this XRReferenceImageLibrary library, string key, byte[] data)
{
if (key == null)
{
throw new ArgumentNullException(nameof(key));
}
library.InternalSetDataForKey(key, data);
}
/// <summary>
/// Sets the <c>XRReferenceImage.name</c> value on the <c><c>XRReferenceImage</c> at <paramref name="index"/>.
/// This value is read-only in the Player; it can only be modified in the Editor.
/// </summary>
/// <param name="library">The <c>XRReferenceImageLibrary</c> being extended.</param>
/// <param name="index">The index of the reference image within the library to modify.</param>
/// <param name="name"></param>
/// <exception cref="System.ArgumentNullException">Thrown if <paramref name="library"/> is <c>null</c>.</exception>
/// <exception cref="System.IndexOutOfRangeException">Thrown if <paramref name="index"/> is not between 0 and <paramref name="library"/><c>.count - 1</c>.</exception>
public static void SetName(this XRReferenceImageLibrary library, int index, string name)
{
ValidateAndThrow(library, index);
var image = library.m_Images[index];
image.m_Name = name;
library.m_Images[index] = image;
}
/// <summary>
/// Creates a <c>RuntimeReferenceImageLibrary</c> from the passed in <c>XRReferenceImageLibrary</c> passed in.
/// </summary>
/// <param name="serializedLibrary">The <c>XRReferenceImageLibrary</c> that is used to create the <c>RuntimeReferenceImageLibrary</c></param>
/// <returns>A new <c>RuntimeReferenceImageLibrary</c> created from the old </returns>
public override RuntimeReferenceImageLibrary CreateRuntimeLibrary(XRReferenceImageLibrary serializedLibrary)
{
if (s_NativeProviderPtr == IntPtr.Zero || s_NativeTrackerCreationJobHandle.Equals(default(JobHandle)))
{
return(null);
}
return(new MagicLeapImageDatabase(serializedLibrary, s_NativeProviderPtr, s_NativeTrackerCreationJobHandle));
}
/// <summary>
/// Sets the <c>XRReferenceImage.specifySize</c> value on the <c><c>XRReferenceImage</c> at <paramref name="index"/>.
/// This value is read-only in the Player; it can only be modified in the Editor.
/// </summary>
/// <param name="library">The <c>XRReferenceImageLibrary</c> being extended.</param>
/// <param name="index">The index of the reference image within the library to modify.</param>
/// <param name="specifySize">Whether <c>XRReferenceImage.size</c> is specified.</param>
/// <exception cref="System.ArgumentNullException">Thrown if <paramref name="library"/> is <c>null</c>.</exception>
/// <exception cref="System.IndexOutOfRangeException">Thrown if <paramref name="index"/> is not between 0 and <paramref name="library"/><c>.count - 1</c>.</exception>
public static void SetSpecifySize(this XRReferenceImageLibrary library, int index, bool specifySize)
{
ValidateAndThrow(library, index);
var image = library.m_Images[index];
image.m_SpecifySize = specifySize;
library.m_Images[index] = image;
}
/// <summary>
/// Sets the <c>XRReferenceImage.size</c> value on the <c><c>XRReferenceImage</c> at <paramref name="index"/>.
/// This value is read-only in the Player; it can only be modified in the Editor.
/// </summary>
/// <param name="library">The <c>XRReferenceImageLibrary</c> being extended.</param>
/// <param name="index">The index of the reference image within the library to modify.</param>
/// <param name="size"></param>
/// <exception cref="System.ArgumentNullException">Thrown if <paramref name="library"/> is <c>null</c>.</exception>
/// <exception cref="System.IndexOutOfRangeException">Thrown if <paramref name="index"/> is not between 0 and <paramref name="library"/><c>.count - 1</c>.</exception>
public static void SetSize(this XRReferenceImageLibrary library, int index, Vector2 size)
{
ValidateAndThrow(library, index);
var image = library.m_Images[index];
image.m_Size = size;
library.m_Images[index] = image;
}
static XRReferenceImage AddRefImageFromMarker(XRReferenceImageLibrary xrReferenceImageLibrary,
MarsMarkerDefinition marsMarkerDefinition)
{
xrReferenceImageLibrary.Add();
// Just added entry is last
var index = xrReferenceImageLibrary.count - 1;
UpdateRefImage(xrReferenceImageLibrary, index, marsMarkerDefinition);
return(xrReferenceImageLibrary[index]);
}
/// <summary>
/// Set the texture on the reference image.
/// </summary>
/// <param name="library">The <see cref="XRReferenceImageLibrary"/> being extended.</param>
/// <param name="index">The reference image index to modify.</param>
/// <param name="texture">The texture to set.</param>
/// <param name="keepTexture">Whether to store a strong reference to the texture. If <c>true</c>,
/// the texture will be available in the Player. Otherwise, <c>XRReferenceImage.texture</c> will be set to <c>null</c>.</param>
/// <exception cref="System.ArgumentNullException">Thrown if <paramref name="library"/> is <c>null</c>.</exception>
/// <exception cref="System.IndexOutOfRangeException">Thrown if <paramref name="index"/> is not between 0 and <paramref name="library"/><c>.count - 1</c>.</exception>
public static void SetTexture(this XRReferenceImageLibrary library, int index, Texture2D texture, bool keepTexture)
{
ValidateAndThrow(library, index);
var referenceImage = library.m_Images[index];
referenceImage.m_SerializedTextureGuid = SerializableGuidUtil.Create(GetGuidForTexture(texture));
referenceImage.m_Texture = keepTexture ? texture : null;
library.m_Images[index] = referenceImage;
}
/// <summary>
/// Creates a <c>UnityEngine.XR.ARSubsystems.RuntimeReferenceImageLibrary</c> from an existing
/// <c>UnityEngine.XR.ARSubsystems.XRReferenceImageLibrary</c>
/// or an empty library if <paramref name="serializedLibrary"/> is <c>null</c>.
/// Use this to construct reference image libraries at runtime. If the library is of type
/// <c>MutableRuntimeReferenceImageLibrary</c>, it is modifiable at runtime.
/// </summary>
/// <param name="serializedLibrary">An existing <c>XRReferenceImageLibrary</c>, or <c>null</c> to create an empty mutable image library.</param>
/// <returns>A new <c>RuntimeReferenceImageLibrary</c> representing the deserialized version of <paramref name="serializedLibrary"/>or an empty library if <paramref name="serializedLibrary"/> is <c>null</c>.</returns>
/// <exception cref="System.NotSupportedException">Thrown if there is no subsystem. This usually means image tracking is not supported.</exception>
public RuntimeReferenceImageLibrary CreateRuntimeLibrary(XRReferenceImageLibrary serializedLibrary = null)
{
CreateSubsystemIfNecessary();
if (subsystem == null)
{
throw new NotSupportedException("No image tracking subsystem found. This usually means image tracking is not supported.");
}
return(subsystem.CreateRuntimeLibrary(serializedLibrary));
}
public static NativeArray <ManagedReferenceImage> ToNativeArray(this XRReferenceImageLibrary library, Allocator allocator)
{
var managedReferenceImages = new NativeArray <ManagedReferenceImage>(library.count, allocator);
for (var i = 0; i < library.count; ++i)
{
managedReferenceImages[i] = new ManagedReferenceImage(library[i]);
}
return(managedReferenceImages);
}
/// <summary>
/// Creates an empty <c>XRReferenceImage<c/> and adds it to the library. The new
/// reference image is inserted at the end of the list of reference images.
/// </summary>
/// <param name="library">The <see cref="XRReferenceImageLibrary"/> being extended.</param>
/// <exception cref="System.ArgumentNullException">Thrown if <paramref name="library"/> is <c>null</c>.</exception>
public static void Add(this XRReferenceImageLibrary library)
{
if (library == null)
{
throw new ArgumentNullException("library");
}
library.m_Images.Add(new XRReferenceImage
{
m_SerializedGuid = SerializableGuidUtil.Create(Guid.NewGuid())
});
}
private unsafe void ChangeARCoreImagesDatabase(XRReferenceImageLibrary library, byte[] arcoreDB)
{
Debug.Log("Initializing DB Creation");
if (arcoreDB == null || arcoreDB.Length == 0)
{
throw new InvalidOperationException(string.Format("Failed to load image library '{0}' - file was empty!", library.name));
}
var guids = new NativeArray <Guid>(library.count, Allocator.Temp);
try
{
for (int i = 0; i < library.count; ++i)
guids[i] = library[i].guid;
fixed(byte *blob = arcoreDB)
{
// Retrieve the ARCore image tracking provider by reflection
var provider = typeof(ARCoreImageTrackingProvider).GetNestedType("Provider", BindingFlags.NonPublic | BindingFlags.Instance);
Debug.Log("retrieved image tracking provider");
// Destroy the current image tracking database
var destroy = provider.GetMethod("UnityARCore_imageTracking_destroy", BindingFlags.NonPublic | BindingFlags.Static);
destroy.Invoke(null, null);
Debug.Log("Destroyed current tracking database");
// Set the image tracking database
var setDatabase = provider.GetMethod("UnityARCore_imageTracking_setDatabase", BindingFlags.NonPublic | BindingFlags.Static);
setDatabase.Invoke(null, new object[]
{
new IntPtr(blob),
arcoreDB.Length,
new IntPtr(guids.GetUnsafePtr()),
guids.Length
});
Debug.Log("Database creation completed");
}
}
catch (Exception e)
{
Debug.LogError(string.Format("Error while loading '{0}': {1}", library.name, e));
}
finally
{
guids.Dispose();
}
// foreach (var referenceImage in library)
// Debug.LogFormat("Image guid: {0}", referenceImage.guid);
}
static string ToInputImageListPath(this XRReferenceImageLibrary library, string destinationDirectory)
{
var entries = new List <string>();
foreach (var referenceImage in library)
{
entries.Add(referenceImage.ToImgDBEntry(destinationDirectory));
}
var path = Path.Combine(destinationDirectory, $"{GetTempFileNameWithoutExtension()}.txt");
File.WriteAllText(path, string.Join("\n", entries));
return(path);
}
public MagicLeapImageDatabase(XRReferenceImageLibrary serializedLibrary, IntPtr nativeProviderHandle, JobHandle imageTrackerCreationJobHandle)
{
m_NativeProviderPtr = nativeProviderHandle;
m_CreateAssociatedNativeTrackerJobHandle = imageTrackerCreationJobHandle;
m_NativePtr = Construct();
if (m_NativePtr == IntPtr.Zero)
{
throw new InvalidOperationException($"Native Library for {serializedLibrary.name} failed to construct.");
}
if (serializedLibrary != null && serializedLibrary.count > 0)
{
DeserializeImageDatabaseFile(serializedLibrary);
}
}
static void ValidateAndThrow(XRReferenceImageLibrary library, int index)
{
if (library == null)
{
throw new ArgumentNullException("library");
}
if (library.count == 0)
{
throw new IndexOutOfRangeException("The reference image library is empty; cannot index into it.");
}
if (index < 0 || index >= library.count)
{
throw new IndexOutOfRangeException(string.Format("{0} is out of range. 'index' must be between 0 and {1}", index, library.count - 1));
}
}
static AssetDeleteResult HandleAssetDelete(XRReferenceImageLibrary xrLibrary)
{
if (MarkerProviderSettings.instance.TryFind(xrLibrary, out var marsLibrary))
{
Debug.LogWarning($"You must delete the MarsMarkerLibrary {marsLibrary} before deleting its associated XRReferenceImageLibrary", marsLibrary);
// Return DidDelete to prevent deleting the asset in this case
return(AssetDeleteResult.DidDelete);
}
if (k_DeletedLibraries.Remove(xrLibrary))
{
return(AssetDeleteResult.DidDelete);
}
return(AssetDeleteResult.DidNotDelete);
}
public static NSString GetARResourceGroupName(this XRReferenceImageLibrary library)
{
if (library.dataStore.TryGetValue(ARKitPackageInfo.identifier, out var data))
{
return(new NSString(ARKitImageDatabase.resourceGroupName));
}
// Otherwise, construct the name based on the library's name + guid
var name = new NSMutableString(library.name);
name.Append(NSString.underscore);
using (var uuid = library.guid.ToNSString())
{
name.Append(uuid);
}
return(name);
}
public unsafe ARCoreImageDatabase(XRReferenceImageLibrary serializedLibrary)
{
if (serializedLibrary == null)
{
m_NativePtr = UnityARCore_ImageDatabase_deserialize(default(NativeView <byte>), default(NativeView <ManagedReferenceImage>));
}
else
{
using (var webRequest = new UnityWebRequest(ARCoreImageTrackingProvider.GetPathForLibrary(serializedLibrary)))
{
webRequest.downloadHandler = new DownloadHandlerBuffer();
webRequest.disposeDownloadHandlerOnDispose = true;
webRequest.SendWebRequest();
while (!webRequest.isDone)
{
}
byte[] libraryBlob = webRequest.downloadHandler.data;
if (libraryBlob == null || libraryBlob.Length == 0)
{
throw new InvalidOperationException(string.Format(
"Failed to load image library '{0}' - file was empty!", serializedLibrary.name));
}
var managedReferenceImages = new NativeArray <ManagedReferenceImage>(serializedLibrary.count, Allocator.Temp);
try
{
for (int i = 0; i < serializedLibrary.count; ++i)
{
managedReferenceImages[i] = new ManagedReferenceImage(serializedLibrary[i]);
}
fixed(byte *blob = libraryBlob)
{
m_NativePtr = UnityARCore_ImageDatabase_deserialize(new NativeView <byte>(blob, libraryBlob.Length), managedReferenceImages);
}
}
finally
{
managedReferenceImages.Dispose();
}
}
}
}
void OnEnable()
{
if (!EditorApplication.isPlayingOrWillChangePlaymode)
{
referenceImageLibrary = serializedObject.FindProperty("referenceImageLibrary");
if (referenceImageLibrary.objectReferenceValue != null)
{
library = referenceImageLibrary.objectReferenceValue as XRReferenceImageLibrary;
drawIndex = new int[library.count];
}
possibleHandlerNames = GetAllHandlerNames();
possibleHandlerNames.Insert(0, "None");
lookupInfo = serializedObject.FindProperty("handlerInfoList");
if (library != null)
{
GetLookUpList();
}
}
}
/// <summary>
/// Sets the image library on the subsystem before Start() is called on the <c>XRImageTrackingSubsystem</c>.
/// </summary>
protected override void OnBeforeStart()
{
if (subsystem.imageLibrary == null && m_SerializedLibrary != null)
{
subsystem.imageLibrary = subsystem.CreateRuntimeLibrary(m_SerializedLibrary);
m_SerializedLibrary = null;
}
UpdateReferenceImages(subsystem.imageLibrary);
SetMaxNumberOfMovingImages(m_MaxNumberOfMovingImages);
enabled = (subsystem.imageLibrary != null);
#if DEVELOPMENT_BUILD
if (subsystem.imageLibrary == null)
{
Debug.LogWarning($"{nameof(ARTrackedImageManager)} '{name}' was enabled but no reference image library is specified. To enable, set a valid reference image library and then re-enable this component.");
}
#endif
}
static byte[] GetLibraryData(XRReferenceImageLibrary library)
{
// 4.2+
if (library.dataStore.TryGetValue(dataStoreKey, out var bytes))
{
return(bytes);
}
// Pre 4.2 fallback
using var webRequest = new UnityWebRequest(ARCoreImageTrackingSubsystem.GetPathForLibrary(library))
{
downloadHandler = new DownloadHandlerBuffer(),
disposeDownloadHandlerOnDispose = true
};
webRequest.SendWebRequest();
while (!webRequest.isDone)
{
}
return(webRequest.downloadHandler.data);
}
public unsafe ARKitImageDatabase(XRReferenceImageLibrary serializedLibrary)
{
if (serializedLibrary == null)
{
nativePtr = UnityARKit_ImageDatabase_createEmpty();
}
else
{
var managedReferenceImages = new NativeArray <ManagedReferenceImage>(serializedLibrary.count, Allocator.Temp);
for (int i = 0; i < serializedLibrary.count; ++i)
{
managedReferenceImages[i] = new ManagedReferenceImage(serializedLibrary[i]);
}
using (managedReferenceImages)
{
var nativeReturnCode = UnityARKit_ImageDatabase_tryCreateFromResourceGroup(
serializedLibrary.name, serializedLibrary.name.Length, serializedLibrary.guid,
managedReferenceImages.GetUnsafePtr(), managedReferenceImages.Length,
out IntPtr ptr);
switch (nativeReturnCode)
{
case SetReferenceLibraryResult.Success:
nativePtr = ptr;
break;
case SetReferenceLibraryResult.FeatureUnavailable:
throw new InvalidOperationException($"Failed to resolve image library '{serializedLibrary.name}'. This feature only works on versions of ARKit 11.3 and newer.");
case SetReferenceLibraryResult.ResourceDoesNotExist:
throw new InvalidOperationException($"Failed to resolve image library '{serializedLibrary.name}'. There is no matching resource group, or the resource group does not contain any reference images.");
default:
throw new InvalidOperationException($"Unexpected return code {nativeReturnCode} encountered while trying to create a reference image library with name {serializedLibrary.name}.");
}
}
}
}
public unsafe override RuntimeReferenceImageLibrary CreateRuntimeLibrary(
XRReferenceImageLibrary serializedLibrary)
{
return(new ARKitImageDatabase(serializedLibrary));
}
