public void UnloadTarget(ImageTargetController target)
{
if (target.Target != null && !TryGetTargetController(target.Target.runtimeID()))
{
return;
}
target.Tracker = null;
}
public void UnloadImageTarget(ImageTargetController controller, System.Action <Target, bool> callback)
{
if (tracker == null)
{
throw new Exception("image tracker is null");
}
tracker.unloadTarget(controller.Target(), EasyARBehaviour.Scheduler, callback);
targetControllers.Remove(controller);
}
internal void LoadImageTarget(ImageTargetController controller, Action <Target, bool> callback)
{
Tracker.loadTarget(controller.Target, EasyARController.Scheduler, (target, status) =>
{
if (TargetLoad != null)
{
TargetLoad(controller, target, status);
}
if (callback != null)
{
callback(target, status);
}
});
allTargetController[controller.Target.runtimeID()] = controller;
}
static private void UpdateScale(ImageTargetController controller, float s)
{
if (Application.isPlaying)
{
return;
}
var vec3Unit = Vector3.one;
if (controller.HorizontalFlip)
{
vec3Unit.x = -vec3Unit.x;
}
controller.transform.localScale = vec3Unit * s;
controller.GizmoData.Scale = s;
controller.GizmoData.ScaleX = controller.transform.localScale.x;
controller.GizmoData.HorizontalFlip = controller.HorizontalFlip;
}
internal void UnloadImageTarget(ImageTargetController controller, Action <Target, bool> callback)
{
if (allTargetController.Remove(controller.Target.runtimeID()))
{
controller.OnTracking(false);
Tracker.unloadTarget(controller.Target, EasyARController.Scheduler, (target, status) =>
{
if (TargetUnload != null)
{
TargetUnload(controller, target, status);
}
if (callback != null)
{
callback(target, status);
}
});
}
}
static void DrawGizmo(ImageTargetController scr, GizmoType gizmoType)
{
var signature = scr.SourceType.ToString();
switch (scr.SourceType)
{
case ImageTargetController.DataSource.ImageFile:
if (!EasyARController.Settings.GizmoConfig.ImageTarget.EnableImageFile)
{
return;
}
signature += scr.ImageFileSource.PathType.ToString() + scr.ImageFileSource.Path;
break;
case ImageTargetController.DataSource.TargetDataFile:
if (!EasyARController.Settings.GizmoConfig.ImageTarget.EnableTargetDataFile)
{
return;
}
signature += scr.TargetDataFileSource.PathType.ToString() + scr.TargetDataFileSource.Path;
break;
case ImageTargetController.DataSource.Target:
if (!EasyARController.Settings.GizmoConfig.ImageTarget.EnableTarget)
{
return;
}
if (scr.Target != null)
{
signature += scr.Target.runtimeID().ToString();
}
break;
default:
break;
}
if (scr.GizmoData.Material == null)
{
scr.GizmoData.Material = new Material(Shader.Find("EasyAR/ImageTargetGizmo"));
}
if (scr.GizmoData.Signature != signature)
{
if (scr.GizmoData.Texture != null)
{
UnityEngine.Object.DestroyImmediate(scr.GizmoData.Texture);
scr.GizmoData.Texture = null;
}
string path;
switch (scr.SourceType)
{
case ImageTargetController.DataSource.ImageFile:
path = scr.ImageFileSource.Path;
if (scr.ImageFileSource.PathType == PathType.StreamingAssets)
{
path = Application.streamingAssetsPath + "/" + scr.ImageFileSource.Path;
}
if (System.IO.File.Exists(path))
{
var sourceData = System.IO.File.ReadAllBytes(path);
scr.GizmoData.Texture = new Texture2D(2, 2);
scr.GizmoData.Texture.LoadImage(sourceData);
scr.GizmoData.Texture.Apply();
UpdateScale(scr, scr.ImageFileSource.Scale);
if (SceneView.lastActiveSceneView)
{
SceneView.lastActiveSceneView.Repaint();
}
}
break;
case ImageTargetController.DataSource.TargetDataFile:
path = scr.TargetDataFileSource.Path;
if (scr.TargetDataFileSource.PathType == PathType.StreamingAssets)
{
path = Application.streamingAssetsPath + "/" + scr.TargetDataFileSource.Path;
}
if (System.IO.File.Exists(path))
{
if (!EasyARController.Initialized)
{
EasyARController.GlobalInitialization();
if (!EasyARController.Initialized)
{
Debug.LogWarning("EasyAR Sense target data gizmo enabled but license key validation failed, target data gizmo will not show");
}
}
var sourceData = System.IO.File.ReadAllBytes(path);
using (Buffer buffer = Buffer.wrapByteArray(sourceData))
{
var targetOptional = ImageTarget.createFromTargetData(buffer);
if (targetOptional.OnSome)
{
using (ImageTarget target = targetOptional.Value)
{
var imageList = target.images();
if (imageList.Count > 0)
{
var image = imageList[0];
scr.GizmoData.Texture = new Texture2D(image.width(), image.height(), TextureFormat.R8, false);
scr.GizmoData.Texture.LoadRawTextureData(image.buffer().data(), image.buffer().size());
scr.GizmoData.Texture.Apply();
}
foreach (var image in imageList)
{
image.Dispose();
}
UpdateScale(scr, target.scale());
if (SceneView.lastActiveSceneView)
{
SceneView.lastActiveSceneView.Repaint();
}
}
}
}
}
break;
case ImageTargetController.DataSource.Target:
if (scr.Target != null)
{
var imageList = (scr.Target as ImageTarget).images();
if (imageList.Count > 0)
{
var image = imageList[0];
scr.GizmoData.Texture = new Texture2D(image.width(), image.height(), TextureFormat.R8, false);
scr.GizmoData.Texture.LoadRawTextureData(image.buffer().data(), image.buffer().size());
scr.GizmoData.Texture.Apply();
}
foreach (var image in imageList)
{
image.Dispose();
}
UpdateScale(scr, (scr.Target as ImageTarget).scale());
if (SceneView.lastActiveSceneView)
{
SceneView.lastActiveSceneView.Repaint();
}
}
break;
default:
break;
}
if (scr.GizmoData.Texture == null)
{
scr.GizmoData.Texture = new Texture2D(2, 2);
scr.GizmoData.Texture.LoadImage(new byte[0]);
scr.GizmoData.Texture.Apply();
}
scr.GizmoData.Signature = signature;
}
if (scr.GizmoData.Material && scr.GizmoData.Texture)
{
scr.GizmoData.Material.SetMatrix("_Transform", scr.transform.localToWorldMatrix);
if (scr.GizmoData.Texture.format == TextureFormat.R8)
{
scr.GizmoData.Material.SetInt("_isRenderGrayTexture", 1);
}
else
{
scr.GizmoData.Material.SetInt("_isRenderGrayTexture", 0);
}
scr.GizmoData.Material.SetFloat("_Ratio", (float)scr.GizmoData.Texture.height / scr.GizmoData.Texture.width);
Gizmos.DrawGUITexture(new Rect(0, 0, 1, 1), scr.GizmoData.Texture, scr.GizmoData.Material);
}
}
public void UpdateFrame(ARSessionUpdateEventArgs args)
{
List <ImageTargetController> currentTrackingControllers = new List <ImageTargetController>();
var results = args.OFrame.results();
foreach (var _result in results)
{
ImageTrackerResult result = null;
if (_result.OnSome)
{
result = _result.Value as ImageTrackerResult;
}
if (result != null)
{
var targetInstances = result.targetInstances();
int centerTargetId = -1;
if (TargetCamera == null)
{
Utility.SetMatrixOnTransform(Camera.main.transform, centerTransform);
}
else
{
Utility.SetMatrixOnTransform(TargetCamera.transform, centerTransform);
}
if (CenterImageTarget != null && CenterImageTarget.Target() != null && CenterTarget == CenterMode.SpecificTarget)
{
centerTargetId = CenterImageTarget.Target().runtimeID();
}
foreach (var targetInstance in targetInstances)
{
var target = targetInstance.target();
if (!target.OnSome)
{
continue;
}
var status = targetInstance.status();
foreach (var targetController in targetControllers)
{
var _target = targetController.Target();
if (target.Value.runtimeID() == _target.runtimeID())
{
if (status == TargetStatus.Tracked)
{
if (!targetController.Tracked)
{
targetController.OnFound();
targetController.Tracked = true;
}
var pose = Utility.Matrix44FToMatrix4x4(targetInstance.pose());
pose = args.ImageRotationMatrixGlobal * pose;
if (CenterTarget == CenterMode.FirstTarget && centerTargetId == -1)
{
centerTargetId = target.Value.runtimeID();
CenterImageTarget = targetController;
}
if (centerTargetId != target.Value.runtimeID())
{
pose = centerTransform * pose;
targetController.OnTracking(pose);
}
else
{
targetController.OnTracking(Matrix4x4.identity);
centerTransform = pose.inverse;
}
currentTrackingControllers.Add(targetController);
}
}
}
target.Value.Dispose();
targetInstance.Dispose();
}
result.Dispose();
}
}
foreach (var targetController in targetControllers)
{
bool contain = false;
foreach (var item in currentTrackingControllers)
{
if (item == targetController)
{
contain = true;
}
}
if (!contain && targetController.Tracked)
{
targetController.OnLost();
targetController.Tracked = false;
}
}
}
