MAXST ZED Implementation

using System;
using System.Collections;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using UnityEngine;
using maxstAR;
using HelperScripts;
using sl;
using UnityEngine.UI;

public class ImageTrackerZedMAXST : ARBehaviour
{
    [SerializeField] private ZEDManager zedManager;

    private Dictionary<string, ImageTrackableBehaviour> imageTrackablesMap =
    new Dictionary<string, ImageTrackableBehaviour>();

    private CameraBackgroundBehaviour cameraBackgroundBehaviour = null;

    private void Awake()
    {
        Init();

        cameraBackgroundBehaviour = FindObjectOfType<CameraBackgroundBehaviour>();
    }

    // Start is called before the first frame update
    void Start()
    {
        QualitySettings.vSyncCount = 0;
        //Application.targetFrameRate = 60;

        imageTrackablesMap.Clear();
        ImageTrackableBehaviour[] imageTrackables = FindObjectsOfType<ImageTrackableBehaviour>();
        foreach (var trackable in imageTrackables)
        {
            imageTrackablesMap.Add(trackable.TrackableName, trackable);
            Debug.Log("Trackable add: " + trackable.TrackableName);
        }

        AddTrackerData();
        TrackerManager.GetInstance().StartTracker(TrackerManager.TRACKER_TYPE_IMAGE);
    }

    // Update is called once per frame
    void Update()
    {
        if (!zedManager.IsZEDReady)
        {
            return;
        }

        //Retrieve Image method
        ZEDMat zedMat = new ZEDMat(1280, 720, ZEDMat.MAT_TYPE.MAT_8U_C4);
        zedManager.zedCamera.RetrieveImage(zedMat, VIEW.LEFT_UNRECTIFIED);
        IntPtr matPtr = zedMat.GetPtr();
        int matWidth = zedMat.GetWidth();
        int matHeight = zedMat.GetHeight();
        int len = matWidth * matHeight * 4;
        byte[] frameBytes = new byte[len];
        Marshal.Copy(matPtr, frameBytes, 0, len);

        if (frameBytes != null)
        {
            Texture2D image = new Texture2D(matWidth, matHeight, TextureFormat.RGBA32, false);
            image.LoadRawTextureData(frameBytes);
            //imageRGBA32.SetPixels(image.GetPixels());
            //imageRGBA32.Apply();
            //rawImage.texture = imageRGBA32;
            CameraDevice.GetInstance().SetNewFrame(image.GetRawTextureData(), image.GetRawTextureData().Length, image.width, image.height, ColorFormat.RGBA8888);
            Destroy(image);
        }

        zedMat.Free();

        DisableAllTrackables();

        TrackingState state = TrackerManager.GetInstance().UpdateTrackingState();

        if (state == null)
        {
            return;
        }

        //cameraBackgroundBehaviour.UpdateCameraBackgroundImage(state);

        TrackingResult trackingResult = state.GetTrackingResult();

        for (int i = 0; i < trackingResult.GetCount(); i++)
        {
            Trackable trackable = trackingResult.GetTrackable(i);
            if (imageTrackablesMap[trackable.GetName()] != null)
            {
                imageTrackablesMap[trackable.GetName()].OnTrackSuccess(
                    trackable.GetId(), trackable.GetName(), trackable.GetPose());
            }
        }
    }

    private void AddTrackerData()
    {
        foreach (var trackable in imageTrackablesMap)
        {
            if (trackable.Value.TrackerDataFileName.Length == 0)
            {
                continue;
            }

            if (trackable.Value.StorageType == StorageType.AbsolutePath)
            {
                TrackerManager.GetInstance().AddTrackerData(trackable.Value.TrackerDataFileName);
                TrackerManager.GetInstance().LoadTrackerData();
            }
            else if(trackable.Value.StorageType == StorageType.StreamingAssets)
            {
                if (Application.platform == RuntimePlatform.Android)
                {
                    StartCoroutine(MaxstARUtil.ExtractAssets(trackable.Value.TrackerDataFileName, (filePath) =>
                    {
                        TrackerManager.GetInstance().AddTrackerData(filePath, false);
                        TrackerManager.GetInstance().LoadTrackerData();
                    }));
                }
                else
                {
                    TrackerManager.GetInstance().AddTrackerData(Application.streamingAssetsPath + "/" + trackable.Value.TrackerDataFileName);
                    TrackerManager.GetInstance().LoadTrackerData();
                }
            }
        }
    }

    private void DisableAllTrackables()
    {
        foreach (var trackable in imageTrackablesMap)
        {
            trackable.Value.OnTrackFail();
        }
    }

    public void SetNormalMode()
    {
        TrackerManager.GetInstance().SetTrackingOption(TrackerManager.TrackingOption.NORMAL_TRACKING);
    }

    public void SetExtendedMode()
    {
        TrackerManager.GetInstance().SetTrackingOption(TrackerManager.TrackingOption.EXTEND_TRACKING);
    }

    public void SetMultiMode()
    {
        TrackerManager.GetInstance().SetTrackingOption(TrackerManager.TrackingOption.MULTI_TRACKING);
    }

    void OnApplicationPause(bool pause)
    {
        if (pause)
        {
            TrackerManager.GetInstance().StopTracker();
        }
        else
        {
            TrackerManager.GetInstance().StartTracker(TrackerManager.TRACKER_TYPE_IMAGE);
        }
    }

    void OnDestroy()
    {
        imageTrackablesMap.Clear();
        TrackerManager.GetInstance().SetTrackingOption(TrackerManager.TrackingOption.NORMAL_TRACKING);
        TrackerManager.GetInstance().StopTracker();
        TrackerManager.GetInstance().DestroyTracker();
    }
}