using UnityEngine;
using UnityEngine.UI;
using UnityEngine.Events;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using AOT;
using SC.XR.Unity;

public class GSXRManager : MonoBehaviour
{

    public static GSXRManager Instance;
    //{
    //    get
    //    {
    //        if (instance == null) instance = FindObjectOfType<GSXRManager>();
    //        if (instance == null) Debug.LogError("GSXRManager object component not found");
    //        return instance;
    //    }
    //}
    //private static GSXRManager instance;

    static public int EyeLayerMax = 8;  
    static public int OverlayLayerMax = 8;  
    static public int RenderLayersMax = 16; 

    public static Action SlamInitializedCallBack;
    //public static Action SlamOnPauseCallback;
    //public static Action SlamOnResumeCallback;


    [SerializeField]
    private SpecificationType m_SpecificationType = SpecificationType.GSXR;
    public SpecificationType SpecificationType {
        get { return m_SpecificationType; }
        private set { m_SpecificationType = value; }
    }

    public enum slamEventType
	{
        kEventNone = 0,
        kEventSdkServiceStarting = 1,
        kEventSdkServiceStarted = 2,
        kEventSdkServiceStopped = 3,
        kEventControllerConnecting = 4,
        kEventControllerConnected = 5,
        kEventControllerDisconnected = 6,
        kEventThermal = 7,
        kEventVrModeStarted = 8,
        kEventVrModeStopping = 9,
        kEventVrModeStopped = 10,
        kEventSensorError = 11,
        kEventMagnometerUncalibrated = 12,
        kEventBoundarySystemCollision = 13,
        kEvent6dofRelocation = 14,
        kEvent6dofWarningFeatureCount = 15,
        kEvent6dofWarningLowLight = 16,
        kEvent6dofWarningBrightLight = 17,
        kEvent6dofWarningCameraCalibration = 18
    }

    public enum controllerBondState
    {
        No_Bond = 0,
        Left_Bond = 1,
        Right_Bond = 2,
        Left_UnBond = 3,
        Right_UnBond = 4,
        OverTime_Bond = 5,
        Unknown = 6
    }




    [Serializable]
    public class SlamSettings
    { 
        public enum eAntiAliasing
        {
            k1 = 1,
            k2 = 2,
            k4 = 4,
        };
		
        public enum eDepth
        {
            k16 = 16,
            k24 = 24
        };
		
        public enum eChromaticAberrationCorrection
        {
            kDisable = 0,
            kEnable = 1
        };
		
        public enum eVSyncCount
        {
			k0 = 0,
            k1 = 1,
            k2 = 2,
        };
		
        public enum eMasterTextureLimit
        {
            k0 = 0, // full size
            k1 = 1, // half size
            k2 = 2, // quarter size
            k3 = 3, // ...
            k4 = 4  // ...
        };
		
        public enum ePerfLevel
        { 
            Minimum = 1,
            Medium = 2,
            Maximum = 3
        };

        public enum eFrustumType
        {
            Camera = 0,
            Device = 1,
        }

        public enum eEyeBufferType
        {
            //Mono = 0,
            StereoSeperate = 1,
            //StereoSingle = 2,
            //Array = 3,
        }

        [Tooltip("If head tracking lost, fade the display")]
        public bool poseStatusFade = true;
        [Tooltip("Use eye tracking (if available)")]
        public bool trackEyes = true;
        [Tooltip("Use position tracking (if available)")]
        public bool trackPosition = true;
        [Tooltip("Track position conversion from meters")]
        public float trackPositionScale = 1;
        [Tooltip("Height of the eyes from base of head")]
        public float headHeight = 0.0750f;
        [Tooltip("Depth of the eyes from center of head")]
        public float headDepth = 0.0805f;
        [Tooltip("Distance between the eyes")]
        public float interPupilDistance = 0.064f;
        //[Tooltip("Distance of line-of-sight convergence (0 disabled)")]
        //public float stereoConvergence = 0;
        //[Tooltip("Pitch angle to the horizon in degrees")]
        //public float horizonElevation = 0;
        [Tooltip("Eye field of view render target reprojection margin (% of fov) [0..]")]
        public float eyeFovMargin = 0.0f;
        [Tooltip("Eye render target scale factor")]
        public float eyeResolutionScaleFactor = 1.0f;
        [Tooltip("Eye render target depth buffer")]
        public eDepth eyeDepth = eDepth.k24;
        [Tooltip("Eye render target MSAA value")]
        public eAntiAliasing eyeAntiAliasing = eAntiAliasing.k2;
        [Tooltip("Overlay render target scale factor")]
        public float overlayResolutionScaleFactor = 1.0f;
        [Tooltip("Overlay render target depth buffer")]
        public eDepth overlayDepth = eDepth.k16;
        [Tooltip("Overlay render target MSAA value")]
        public eAntiAliasing overlayAntiAliasing = eAntiAliasing.k1;
        [Tooltip("Limit refresh rate")]
        public eVSyncCount vSyncCount = eVSyncCount.k1;
        [Tooltip("Chromatic Aberration Correction")]
        public eChromaticAberrationCorrection chromaticAberationCorrection = eChromaticAberrationCorrection.kEnable;
        [Tooltip("QualitySettings TextureQuality FullRes, HalfRes, etc.")]
        public eMasterTextureLimit masterTextureLimit = eMasterTextureLimit.k0;
        [Tooltip("CPU performance level")]
        public ePerfLevel cpuPerfLevel = ePerfLevel.Medium;
        [Tooltip("GPU performance level")]
        public ePerfLevel gpuPerfLevel = ePerfLevel.Medium;
        [Tooltip("Foveated render gain [1..], 0/feature disabled")]
        public Vector2 foveationGain = new Vector2(0.0f, 0.0f);
        [Tooltip("Foveated render hires area [0..]")]
        public float foveationArea = 0.0f;
        [Tooltip("Foveated render min pixel density [1/16..1]")]
        public float foveationMinimum = 0.25f;
        [Tooltip("Use perspective of unity camera or device frustum data")]
        public eFrustumType frustumType = eFrustumType.Camera;
        [Tooltip("Display buffer type (default stereo seperate)")]
        public eEyeBufferType displayType = eEyeBufferType.StereoSeperate;
    }
    [SerializeField]
    public SlamSettings settings;

    [Serializable]
    public class SlamStatus
    {
        [Tooltip("SnapdragonVR SDK Initialized")]
        public bool initialized = false;
        [Tooltip("SnapdragonVR SDK Running")]
        public bool running = false;
        [Tooltip("SnapdragonVR SDK Pose Status: 0/None, 1/Rotation, 2/Position, 3/RotationAndPosition")]
        public int pose = 0;
    }
    [SerializeField]
    public SlamStatus status;

    public enum eFadeState { FadeIn, FadeOut }
    [NonSerialized]
    public eFadeState fadeState = eFadeState.FadeIn;
    [NonSerialized]
    public float fadeDuration = 0.5f;

    [Header("Camera Rig")]
    public Transform head;
    public Transform gaze;
    public Camera monoCamera;
    public Camera leftCamera;
    public Camera rightCamera;
    public Camera leftOverlay;
    public Camera rightOverlay;
    public Camera monoOverlay;
    public GSXROverlay fadeOverlay;
    public GSXROverlay reticleOverlay;

    private bool IsUseOpticsCalibration = true;
    private bool IsUseCommonEvent = false;

    public Vector2 FocalPoint { get; set; } // Foveated Rendering Focal Point

    public int FrameCount { get { return frameCount; } }
	
    private int	frameCount = 0;
	private static WaitForEndOfFrame waitForEndOfFrame = new WaitForEndOfFrame();
	public GSXRPlugin plugin = null;
    private float sensorWarmupDuration = 0.25f;
    private List<GSXREye> eyes = new List<GSXREye>(EyeLayerMax);
	private List<GSXROverlay> overlays = new List<GSXROverlay>(OverlayLayerMax);
    private bool disableInput = false;
    private Coroutine onResume = null;
    private Coroutine submitFrame = null;

    private Matrix4x4 headDeltaInitLocalToWorld = Matrix4x4.identity;

    public Material DepthM;
    public bool IsCreateDepthRT = false;
    private bool IsDontDestroyOnLoad = true;
    /// <summary>
    /// Slam event listener.
    /// </summary>
    public interface SlamEventListener {
		/// <summary>
		/// Raises the slam event event.
		/// </summary>
		/// <param name="ev">Ev.</param>
		void OnSlamEvent (SlamEvent ev);
	};

    public enum slamThermalLevel
    {
        kSafe,
        kLevel1,
        kLevel2,
        kLevel3,
        kCritical,
        kNumThermalLevels
    };

    public enum slamThermalZone
    {
        kCpu,
        kGpu,
        kSkin,
        kNumThermalZones
    };

    public struct slamEventData_Thermal
    {
        public slamThermalZone zone;               //!< Thermal zone
        public slamThermalLevel level;             //!< Indication of the current zone thermal level
    };

    [StructLayout(LayoutKind.Explicit)]
    public struct slamEventData
    {
        [FieldOffset(0)]
        public slamEventData_Thermal thermal;
        //[FieldOffset(0)]
        //public slamEventData_New newData;
    }

	public struct SlamEvent
	{
		public slamEventType eventType;      //!< Type of event
		public uint deviceId;               //!< An identifier for the device that generated the event (0 == HMD)
		public float eventTimeStamp;        //!< Time stamp for the event in seconds since the last BeginVr call
        public slamEventData eventData;      //!< Event specific data payload
    };

    // david start
    public struct SCSingleLayerData
    {
        public UInt32 layerId;
        public UInt32 parentLayerId;
        public UInt32 layerTextureId;
        [MarshalAsAttribute(UnmanagedType.ByValArray, SizeConst = 16)]
        public float[] modelMatrixData;
        public UInt32 editFlag;
        public int z;
        [MarshalAsAttribute(UnmanagedType.ByValArray, SizeConst = 12)]
        public float[] vertexPosition;
        [MarshalAsAttribute(UnmanagedType.ByValArray, SizeConst = 8)]
        public float[] vertexUV;
        public float alpha;
        public byte bOpaque;
        public UInt32 taskId;
    };
    public struct SCAllLayers
    {
        public UInt32 layerNum;
        [MarshalAsAttribute(UnmanagedType.ByValArray, SizeConst = 16)]
        public float[] viewMatrixData;
        public IntPtr layerData;
    };
    // david end
	private List<SlamEventListener> 	eventListeners = new List<SlamEventListener>();

    public bool Initialized
    {
        get { return status.initialized; }
    }

    public bool IsRunning
    {
        get { return status.running; }
    }

    public bool DisableInput
    {
        get { return disableInput; }
        set { disableInput = value; }
    }

	void Awake() {
        if (Instance) {
            DestroyImmediate(gameObject);
            return;
        }
        Instance = this;


        if (!ValidateReferencedComponents ())
		{
			enabled = false;
			return;
		}
        RegisterListeners();
        Input.backButtonLeavesApp = true;
        Screen.sleepTimeout = SleepTimeout.NeverSleep;
        Application.targetFrameRate = -1;

        if (API_Module_SDKConfiguration.HasKey("Module_Slam", "IsCreateDepthRT")) {
            IsCreateDepthRT = API_Module_SDKConfiguration.GetBool("Module_Slam", "IsCreateDepthRT", 0);
            DebugMy.Log("IsCreateDepthRT:" + IsCreateDepthRT, this, true);
        }

    }

    void OnGUI() { 
    
    }
    bool ValidateReferencedComponents()
	{
		plugin = GSXRPlugin.Instance;
		if(plugin == null)
		{
			Debug.LogError("slam Plugin failed to load. Disabling...");
			return false;
		}

		if(head == null)
		{
			Debug.LogError("Required head gameobject not found! Disabling...");
			return false;
		}

		if(monoCamera == null && (leftCamera == null || rightCamera == null))
		{
			Debug.LogError("Required eye components are missing! Disabling...");
			return false;
		}

		return true;
	}
#if UNITY_2018
    void OnEnable()
    {
        if (UnityEngine.Rendering.GraphicsSettings.renderPipelineAsset)
        {
            UnityEngine.Experimental.Rendering.RenderPipeline.beginCameraRendering += OnPreRenderEvent;
        }
    }

    void OnDisable()
    {
        if (UnityEngine.Rendering.GraphicsSettings.renderPipelineAsset)
        {
            UnityEngine.Experimental.Rendering.RenderPipeline.beginCameraRendering -= OnPreRenderEvent;
        }
    }

    private void OnPreRenderEvent(Camera camera)
    {
        camera.SendMessage("OnPreRenderEvent", SendMessageOptions.DontRequireReceiver);
    }
#endif
    IEnumerator Start ()
	{
		yield return StartCoroutine(Initialize());
        status.initialized = plugin.IsInitialized();

        SetOverlayFade(eFadeState.FadeIn);

        yield return StartCoroutine(plugin.BeginVr((int)settings.cpuPerfLevel, (int)settings.gpuPerfLevel));

        /// for some platform plugin.BeginVr return so fast,so need check plugin.IsRunning() and Wait
        int waitFrameCount = 200;
        while ( !plugin.IsRunning() && waitFrameCount >=0) {
            yield return null;
            waitFrameCount--;
        }
        ///

        if (!plugin.IsRunning())
        {
            Debug.LogError("Slam failed!");
            Application.Quit();
            yield return null;  // Wait one frame
        }

        float recenterTimeout = 1f;
        while (!plugin.RecenterTracking() && recenterTimeout > 0f)
        {
            yield return null;  // Wait one frame
            recenterTimeout -= Time.deltaTime;
        }

        yield return new WaitForSecondsRealtime(sensorWarmupDuration);

        submitFrame = StartCoroutine(SubmitFrame());

        status.running = true;

        SlamInitializedCallBack?.Invoke();  //Slam initialization complete callback

        plugin.GSXR_Set_GlassDisconnectedCallBack(GlassDisconnetedCallBack);  //Register glasses disconnection callback


        Debug.Log("Slam initialized!");
        
        if (API_Module_SDKConfiguration.HasKey("Module_Slam", "IsUseCommonEvent")) {
            IsUseCommonEvent = API_Module_SDKConfiguration.GetBool("Module_Slam", "IsUseCommonEvent", 1);
            DebugMy.Log("IsUseCommonEvent:" + IsUseCommonEvent, this, true);
        }
        if (IsUseCommonEvent) {
            gameObject.AddComponent<Module_CommonEvent>();
        }

        DebugMy.Log("SDK SpecificationType:" + API_GSXR_Slam.SlamManager.SpecificationType + ":" + plugin.GSXR_Get_Version(), this, true);

        if (API_Module_SDKConfiguration.HasKey("Module_Slam", "IsUseOpticsCalibration")) {
            IsUseOpticsCalibration = API_Module_SDKConfiguration.GetBool("Module_Slam", "IsUseOpticsCalibration", 1);
            DebugMy.Log("IsUseOpticsCalibration:" + IsUseOpticsCalibration, this, true);
        }

        if (API_Module_SDKConfiguration.HasKey("Module_Slam", "trackPositionScale")) {
            settings.trackPositionScale = API_Module_SDKConfiguration.GetFloat("Module_Slam", "trackPositionScale", 1);
            DebugMy.Log("settings.trackPositionScale:" + settings.trackPositionScale, this, true);
        }

        Vector3 localLeftShoulder=Vector3.zero;
        if (API_Module_SDKConfiguration.HasKey("Module_Slam", "LeftShoulderX") && API_Module_SDKConfiguration.HasKey("Module_Slam", "LeftShoulderY") && API_Module_SDKConfiguration.HasKey("Module_Slam", "LeftShoulderZ")) {
            localLeftShoulder = new Vector3(API_Module_SDKConfiguration.GetFloat("Module_Slam", "LeftShoulderX", 0.0f), API_Module_SDKConfiguration.GetFloat("Module_Slam", "LeftShoulderY", 0.0f), API_Module_SDKConfiguration.GetFloat("Module_Slam", "LeftShoulderZ", 0.0f));
        }

        if (API_Module_SDKConfiguration.HasKey("Module_SDKSystem", "IsDontDestroyOnLoad"))
        {
            IsDontDestroyOnLoad = API_Module_SDKConfiguration.GetBool("Module_SDKSystem", "IsDontDestroyOnLoad", 1);
        }
        shoulder = new Shoulder(head, localLeftShoulder == Vector3.zero ? new Vector3(-0.15f,-0.08f,-0.1f): localLeftShoulder);
    }

    [MonoPInvokeCallback(typeof(Action))]
    private static void GlassDisconnetedCallBack() {
        Debug.Log("GlassDisconnetedCallBack");
        Application.Quit();
    }



    IEnumerator Initialize()
	{
		// Plugin must be initialized OnStart in order to properly
		// get a valid surface
//        GameObject mainCameraGo = GameObject.FindWithTag("MainCamera");
//        if (mainCameraGo)
//        {
//            mainCameraGo.SetActive(false);
//
//            Debug.Log("Camera with MainCamera tag found.");
//            if (!disableInput)
//            {
//                Debug.Log("Will use translation and orientation from the MainCamera.");
//                transform.position = mainCameraGo.transform.position;
//                transform.rotation = mainCameraGo.transform.rotation;
//            }
//
//            Debug.Log("Disabling Camera with MainCamera tag");
//        }

        GL.Clear(false, true, Color.black);

		yield return StartCoroutine(plugin.Initialize());
        InitializeCameras();
		InitializeEyes();
        InitializeOverlays();

        int trackingMode = (int)GSXRPlugin.TrackingMode.kTrackingOrientation;

        if (API_Module_SDKConfiguration.HasKey("Module_Slam", "IsSlamUse3Dof")) {
            if (API_Module_SDKConfiguration.GetBool("Module_Slam", "IsSlamUse3Dof", 0)) {
                DebugMy.Log("Slam Use3Dof", this, true);
                settings.trackPosition = false;
            }
        }

        if (settings.trackPosition)
            trackingMode |= (int)GSXRPlugin.TrackingMode.kTrackingPosition;
        if (settings.trackEyes)
            trackingMode |= (int)GSXRPlugin.TrackingMode.kTrackingEye;

        plugin.SetTrackingMode(trackingMode);

        plugin.SetVSyncCount((int)settings.vSyncCount);
        QualitySettings.vSyncCount = (int)settings.vSyncCount;
    }

    Matrix4x4 invertZ = new Matrix4x4(
            new Vector4(1, 0, 0, 0),
            new Vector4(0, 1, 0, 0),
            new Vector4(0, 0, -1, 0),
            new Vector4(0, 0, 0, 1));

    private void InitializeCameras()
    {
        float stereoConvergence = plugin.deviceInfo.targetFrustumConvergence; //settings.stereoConvergence
        float horizonElevation = plugin.deviceInfo.targetFrustumPitch; //settings.horizonElevation
        float convergenceAngle = 0f;
        if (stereoConvergence > Mathf.Epsilon) convergenceAngle = Mathf.Rad2Deg * Mathf.Atan2(0.5f * settings.interPupilDistance, stereoConvergence);
        else if (stereoConvergence < -Mathf.Epsilon) convergenceAngle = -Mathf.Rad2Deg * Mathf.Atan2(0.5f * settings.interPupilDistance, -stereoConvergence);

        // left
        Vector3 eyePos;
        eyePos.x = -0.5f * settings.interPupilDistance;
        eyePos.y = (!settings.trackPosition ? settings.headHeight : 0);
        eyePos.z = (!settings.trackPosition ? settings.headDepth : 0);
        eyePos += head.transform.localPosition;

        Quaternion eyeRot;
        eyeRot = Quaternion.Euler(horizonElevation, convergenceAngle, 0);

        if (leftCamera != null)
        {
            leftCamera.transform.localPosition = eyePos;
            leftCamera.transform.localRotation = eyeRot;
        }
        if (leftOverlay != null)
        {
            leftOverlay.transform.localPosition = eyePos;
            leftOverlay.transform.localRotation = eyeRot;
        }

        // right
        eyePos.x *= -1;
        eyeRot = Quaternion.Euler(horizonElevation, -convergenceAngle, 0);

        if (rightCamera != null)
        {
            rightCamera.transform.localPosition = eyePos;
            rightCamera.transform.localRotation = eyeRot;
        }
        if (rightOverlay != null)
        {
            rightOverlay.transform.localPosition = eyePos;
            rightOverlay.transform.localRotation = eyeRot;
        }

        // mono
        eyePos.x = 0.0f;
        eyeRot = Quaternion.Euler(horizonElevation, 0, 0);
        if (monoCamera != null)
        {
            monoCamera.transform.localPosition = eyePos;
            monoCamera.transform.localRotation = eyeRot;
        }
        if (monoOverlay != null)
        {
            monoOverlay.transform.localPosition = eyePos;
            monoOverlay.transform.localRotation = eyeRot;
        }
    }

    private void AddEyes(Camera cam, GSXREye.eSide side)
    {
        bool enableCamera = false;
        var eyesFound = cam.gameObject.GetComponents<GSXREye>();
        for (int i = 0; i < eyesFound.Length; i++)
        {
            eyesFound[i].Side = side;
            if (eyesFound[i].imageType == GSXREye.eType.RenderTexture) enableCamera = true;
        }
        eyes.AddRange(eyesFound);
        if (eyesFound.Length == 0)
        {
            var eye = cam.gameObject.AddComponent<GSXREye>();
            eye.Side = side;
            eyes.Add(eye);
            enableCamera = true;
        }
#if UNITY_5_4 || UNITY_5_5
        cam.hdr = false;
#else // UNITY_5_6 plus
        cam.allowHDR = false;
        cam.allowMSAA = false;
#endif
        //cam.enabled = enableCamera;
    }

	private void InitializeEyes()
	{
        eyes.Clear();
        if (monoCamera != null && monoCamera.gameObject.activeSelf)
        {
            AddEyes(monoCamera, GSXREye.eSide.Both);
        }
        if (leftCamera != null && leftCamera.gameObject.activeSelf)
        {
            AddEyes(leftCamera, GSXREye.eSide.Left);
        }
        if (rightCamera != null && rightCamera.gameObject.activeSelf)
        {
            AddEyes(rightCamera, GSXREye.eSide.Right);
        }
        for (int i = 0; i < GSXREye.Instances.Count; i++)
        {
            var eye = GSXREye.Instances[i];
            if (!eyes.Contains(eye))
            {
                eyes.Add(eye); // Add eyes found outside of slam camera hierarchy
            }
        }

        GSXRPlugin.DeviceInfo info = plugin.deviceInfo;

		foreach(GSXREye eye in eyes)
		{
            if (eye == null) continue;

            eye.FovMargin               = settings.eyeFovMargin;
			eye.Format					= RenderTextureFormat.Default;
			eye.Resolution  			= new Vector2(info.targetEyeWidthPixels, info.targetEyeHeightPixels);
            eye.ResolutionScaleFactor   = settings.eyeResolutionScaleFactor;
			eye.Depth 					= (int)settings.eyeDepth;
			eye.AntiAliasing 			= (int)settings.eyeAntiAliasing;	// hdr not supported with antialiasing
            eye.FrustumType             = (int)settings.frustumType;
            eye.OnPreRenderListener     = OnPreRenderListener;
            eye.OnPostRenderListener    = OnPostRenderListener;

            eye.Initialize();
		}
	}

    private void AddOverlays(Camera cam, GSXROverlay.eSide side)
    {
        bool enableCamera = false;
        var overlaysFound = cam.gameObject.GetComponents<GSXROverlay>();
        for (int i = 0; i < overlaysFound.Length; i++)
        {
            overlaysFound[i].Side = side;
            if (overlaysFound[i].imageType == GSXROverlay.eType.RenderTexture) enableCamera = true;
        }
        overlays.AddRange(overlaysFound);
        if (overlaysFound.Length == 0)
        {
            var overlay = cam.gameObject.AddComponent<GSXROverlay>();
            overlay.Side = side;
            overlays.Add(overlay);
            enableCamera = true;
        }
#if UNITY_5_4 || UNITY_5_5
        cam.hdr = false;
#else // UNITY_5_6 plus
        cam.allowHDR = false;
        cam.allowMSAA = false;
#endif
        cam.enabled = enableCamera;
    }

    private void InitializeOverlays()
    {
        overlays.Clear();
        if (leftOverlay != null && leftOverlay.gameObject.activeSelf)
        {
            AddOverlays(leftOverlay, GSXROverlay.eSide.Left);
        }
        if (rightOverlay != null && rightOverlay.gameObject.activeSelf)
        {
            AddOverlays(rightOverlay, GSXROverlay.eSide.Right);
        }
        if (monoOverlay != null && monoOverlay.gameObject.activeSelf)
        {
            AddOverlays(monoOverlay, GSXROverlay.eSide.Both);
        }
        for (int i = 0; i < GSXROverlay.Instances.Count; i++)
        {
            var overlay = GSXROverlay.Instances[i];
            if (!overlays.Contains(overlay))
            {
                overlays.Add(overlay); // Add overlays found outside of slam camera hierarchy
            }
        }

        GSXRPlugin.DeviceInfo info = plugin.deviceInfo;

        foreach (GSXROverlay overlay in overlays)
        {
            if (overlay == null) continue;

            overlay.Format                  = RenderTextureFormat.Default;
            overlay.Resolution              = new Vector2(info.targetEyeWidthPixels, info.targetEyeHeightPixels);
            overlay.ResolutionScaleFactor   = settings.overlayResolutionScaleFactor;
            overlay.Depth                   = (int)settings.overlayDepth;
            overlay.AntiAliasing            = (int)settings.overlayAntiAliasing;  // hdr not supported with antialiasing
            overlay.FrustumType             = (int)settings.frustumType;
            overlay.OnPreRenderListener     = OnPreRenderListener;
            overlay.OnPostRenderListener    = OnPostRenderListener;

            overlay.Initialize();
        }
    }

    public void SetOverlayFade(eFadeState fadeValue)
    {
        fadeState = fadeValue;
        var startAlpha = fadeState == eFadeState.FadeIn ? 1f : 0f;
        UpdateOverlayFade(startAlpha);
    }

    public bool IsOverlayFading()
    {
        return !Mathf.Approximately((float)fadeState, fadeAlpha);
    }

    private float fadeAlpha = 0f;
    private void UpdateOverlayFade(float targetAlpha, float rate = 0)
    {
        if (fadeOverlay == null) return;

        fadeAlpha = rate > 0 ? Mathf.MoveTowards(fadeAlpha, targetAlpha, rate) : targetAlpha;

        var fadeTexture = fadeOverlay.imageTexture as Texture2D;
        if (fadeTexture != null)
        {
            var fadeColors = fadeTexture.GetPixels();
            for (int i = 0; i < fadeColors.Length; ++i)
            {
                fadeColors[i].a = fadeAlpha;
            }
            fadeTexture.SetPixels(fadeColors);
            fadeTexture.Apply(false);
        }

        var isActive = fadeAlpha > 0.0f;
        if (fadeOverlay.enabled != isActive)
        {
            fadeOverlay.enabled = isActive;
        }
    }

    IEnumerator SubmitFrame ()
	{
        Vector3 frustumSize = Vector3.zero;
        frustumSize.x = 0.5f * (plugin.deviceInfo.targetFrustumLeft.right - plugin.deviceInfo.targetFrustumLeft.left);
        frustumSize.y = 0.5f * (plugin.deviceInfo.targetFrustumLeft.top - plugin.deviceInfo.targetFrustumLeft.bottom);
        frustumSize.z = plugin.deviceInfo.targetFrustumLeft.near;
        //Debug.LogFormat("SubmitFrame: Frustum Size ({0:F2}, {1:F2}, {2:F2})", frustumSize.x, frustumSize.y, frustumSize.z);

        while (true)
		{
			yield return waitForEndOfFrame;//固定帧测试

            if ((plugin.GetTrackingMode() & (int)GSXRPlugin.TrackingMode.kTrackingEye) != 0) // Request eye pose
            {
                status.pose |= plugin.GSXR_Get_EyePose(ref eyePose);
            }
            var eyePoint = Vector3.zero;
            if ((status.pose & (int)GSXRPlugin.TrackingMode.kTrackingEye) != 0) // Valid eye pose
            {
                //Debug.LogFormat("Left Eye Position: {0}, Direction: {1}", eyePose.leftPosition.ToString(), eyePose.leftDirection.ToString());
                //Debug.LogFormat("Right Eye Position: {0}, Direction: {1}", eyePose.rightPosition.ToString(), eyePose.rightDirection.ToString());
                //Debug.LogFormat("Combined Eye Position: {0}, Direction: {1}", eyePose.combinedPosition.ToString(), eyePose.combinedDirection.ToString());
                var combinedDirection = Vector3.zero;
                if ((eyePose.leftStatus & (int)GSXRPlugin.EyePoseStatus.kGazeVectorValid) != 0) combinedDirection += eyePose.leftDirection;
                if ((eyePose.rightStatus & (int)GSXRPlugin.EyePoseStatus.kGazeVectorValid) != 0) combinedDirection += eyePose.rightDirection;
                //if ((eyePose.combinedStatus & (int)GSXRPlugin.EyePoseStatus.kGazeVectorValid) != 0) combinedDirection += eyePose.combinedDirection;
                if (combinedDirection.sqrMagnitude > 0f)
                {
                    combinedDirection.Normalize();
                    //Debug.LogFormat("Eye Direction: ({0:F2}, {1:F2}, {2:F2})", combinedDirection.x, combinedDirection.y, combinedDirection.z);

                    float denominator = Vector3.Dot(combinedDirection, Vector3.forward);
                    if (denominator > float.Epsilon)
                    {
                        // eye direction intersection with frustum near plane (left)
                        eyePoint = combinedDirection * frustumSize.z / denominator;
                        eyePoint.x /= frustumSize.x; // [-1..1]
                        eyePoint.y /= frustumSize.y; // [-1..1]
                        //Debug.LogFormat("Eye Point: ({0:F2}, {1:F2})", eyePoint.x, eyePoint.y);
                    }
                }
            }
            var currentGain = GSXROverrideSettings.FoveateGain == Vector2.zero ?
                settings.foveationGain : GSXROverrideSettings.FoveateGain;
            var currentArea = GSXROverrideSettings.FoveateArea == 0f ?
                settings.foveationArea : GSXROverrideSettings.FoveateArea;
            var currentMinimum = GSXROverrideSettings.FoveateMinimum == 0f ?
                settings.foveationMinimum : GSXROverrideSettings.FoveateMinimum;
            for (int i = 0; i < eyes.Count; i++)
            {
                var eye = eyes[i];
                if (eye.TextureId > 0 && eye.ImageType == GSXREye.eType.RenderTexture)
                {
                    plugin.SetFoveationParameters(eye.TextureId, eye.PreviousId, eyePoint.x, eyePoint.y, currentGain.x, currentGain.y, currentArea, currentMinimum);
                    plugin.ApplyFoveation();
                }
            }

            var horizontalFieldOfView = 0f;
            if (settings.eyeFovMargin > 0f)
            {
                horizontalFieldOfView = (monoCamera.enabled ? monoCamera.fieldOfView / monoCamera.aspect : leftCamera.fieldOfView / leftCamera.aspect) * Mathf.Deg2Rad;
            } 
            plugin.SubmitFrame(frameCount, horizontalFieldOfView, (int)settings.displayType);
            frameCount++;
		}
	}

	public bool RecenterTracking()
	{
        if (!Initialized)
            return false;

        return plugin.RecenterTracking();
	}

	void OnPreRenderListener (int sideMask, int textureId, int previousId)
	{
        if (!IsRunning)
            return;

        var currentGain = GSXROverrideSettings.FoveateGain == Vector2.zero ?
            settings.foveationGain : GSXROverrideSettings.FoveateGain;
        var currentArea = GSXROverrideSettings.FoveateArea == 0f ?
            settings.foveationArea : GSXROverrideSettings.FoveateArea;
        var currentMinimum = GSXROverrideSettings.FoveateMinimum == 0f ?
            settings.foveationMinimum : GSXROverrideSettings.FoveateMinimum;
        plugin.SetFoveationParameters(textureId, previousId, FocalPoint.x, FocalPoint.y, currentGain.x, currentGain.y, currentArea, currentMinimum);

        plugin.BeginEye(sideMask, frameDelta);
	}

	void OnPostRenderListener (int sideMask, int layerMask)
	{
        if (!IsRunning)
            return;

        plugin.EndEye (sideMask, layerMask);
	}

    public void SetPause(bool pause)
	{
        if (!Initialized)
			return;
        if (pause)
		{
            OnPause();
		}
        else
        {
            onResume = StartCoroutine(OnResume());
		}
    }

    void OnPause()
	{
        //Debug.Log("GSXRManager.OnPause()");

        status.running = false;

        if (onResume != null) {
            StopCoroutine(onResume);
            onResume = null;
        }

        if (submitFrame != null) { StopCoroutine(submitFrame); submitFrame = null; }

        if (plugin.IsRunning()) plugin.EndVr();


    }

    IEnumerator OnResume()
	{
        //Debug.Log("GSXRManager.OnResume()");

        SetOverlayFade(eFadeState.FadeIn);

        yield return StartCoroutine(plugin.BeginVr((int)settings.cpuPerfLevel, (int)settings.gpuPerfLevel));

        float recenterTimeout = 1f;
        while (!plugin.RecenterTracking() && recenterTimeout > 0f)
        {
            yield return null;  // Wait one frame
            recenterTimeout -= Time.deltaTime;
        }

        yield return new WaitForSecondsRealtime(sensorWarmupDuration);

		submitFrame = StartCoroutine (SubmitFrame ());

        status.running = plugin.IsRunning();
        onResume = null;
        onApplicationPauseDele?.Invoke(false);
    }

    [NonSerialized]
    public GSXRPlugin.HeadPose headPose;
    [NonSerialized]
    public GSXRPlugin.EyePose eyePose;
    [NonSerialized]
    public Vector3 eyeDirection = Vector3.forward;
    [NonSerialized]
    public Vector2 eyeFocus = Vector2.zero;
    [NonSerialized]
    public float eyeSmoother = 0.2f;
    [NonSerialized]
    public float[] frameDelta = new float[9];
	
	public Vector3 modifyPosition = Vector3.zero;
	public Quaternion modifyOrientation = Quaternion.identity;

    bool outBload = false;
    float[] outTransformArray = new float[32];
    Matrix4x4 leftcalib = Matrix4x4.identity;
    Matrix4x4 rightCalib = Matrix4x4.identity;


    bool isRotNan=false;
    bool isPosNan=false;
    void LateUpdate()
    {
        if (!IsRunning)
        {
            return;
        }

        int trackingMode = plugin.GetTrackingMode();
        var prevOrientation = headPose.orientation;

        status.pose = plugin.GetHeadPose(ref headPose, frameCount);


        if (float.IsNaN(headPose.position.x) || float.IsNaN(headPose.position.y) || float.IsNaN(headPose.position.z))
        {
            DebugMy.Log("Position is " + headPose.position + " Error!!!!!!!!!!!!!!!!!!!!!!!!!!!", this, true);
            if (!isPosNan)
            {
                isPosNan = true;
                headPose.position = Vector3.zero;
                API_Module_DetectorSystem_Notice.SetNotice("The device position is NAN", "Please Reboot recovery", NoticeType.Warning, 0.8f, AlignmentType.Center, FollowType.False);
                API_Module_DetectorSystem_Notice.Show(1.5f);
            }
        }
        else
        {
            if (isPosNan)
            {
                isPosNan = false;
                DebugMy.Log("Position is " + headPose.position + " Success", this, true);
            }
           
        }
        if (float.IsNaN(headPose.orientation.x) || float.IsNaN(headPose.orientation.y) || float.IsNaN(headPose.orientation.z) || float.IsNaN(headPose.orientation.w))
        {

            DebugMy.Log("rotation is " + headPose.orientation + " Error!!!!!!!!!!!!!!!!!!!!!!!!!!!", this, true);          
            if (!isRotNan)
            {
                isRotNan = true;
                headPose.orientation = Quaternion.identity;
                API_Module_DetectorSystem_Notice.SetNotice("The device rotation is NAN", "Please Reboot recovery", NoticeType.Warning, 0.8f, AlignmentType.Center, FollowType.False);
                API_Module_DetectorSystem_Notice.Show(1.5f);
            }

        }
        else
        {
            if (isRotNan)
            {
                isRotNan = false;
                DebugMy.Log("rotation is " + headPose.orientation + "Success", this, true);
            }
        }


        if ((trackingMode & (int)GSXRPlugin.TrackingMode.kTrackingEye) != 0)
        {
            status.pose |= plugin.GSXR_Get_EyePose(ref eyePose, frameCount);
        }

        if (!disableInput)
        {
            if ((status.pose & (int)GSXRPlugin.TrackingMode.kTrackingOrientation) != 0)
            {
                head.transform.localRotation = headPose.orientation;

                // delta orientation screen space x, y offset for foveated rendering
                var deltaOrientation = Quaternion.Inverse(prevOrientation) * headPose.orientation;
                var lookDirection = deltaOrientation * Vector3.forward;
                //Debug.LogFormat("Look Direction: {0}", lookDirection.ToString());
                lookDirection *= plugin.deviceInfo.targetFrustumLeft.near / lookDirection.z;
                float xTotal = 0.5f * (plugin.deviceInfo.targetFrustumLeft.right - plugin.deviceInfo.targetFrustumLeft.left);
                float xAdjust = (xTotal != 0.0f) ? lookDirection.x / xTotal : 0.0f;
                float yTotal = 0.5f * (plugin.deviceInfo.targetFrustumLeft.top - plugin.deviceInfo.targetFrustumLeft.bottom);
                float yAdjust = (yTotal != 0.0f) ? lookDirection.y / yTotal : 0.0f;
                //xAdjust *= 0.5f * plugin.deviceInfo.targetEyeWidthPixels;
                //yAdjust *= 0.5f * plugin.deviceInfo.targetEyeHeightPixels;

                // rotation around z [cos(z), sin(z), 0], [-sin(z), cos(z), 0], [0, 0, 1]
                Vector3 deltaEulers = deltaOrientation.eulerAngles;
                float cosZ = Mathf.Cos(deltaEulers.z * Mathf.Deg2Rad);
                float sinZ = Mathf.Sin(deltaEulers.z * Mathf.Deg2Rad);

                // Output rotation and translation
                frameDelta[0] = cosZ;
                frameDelta[1] = sinZ;
                frameDelta[2] = 0.0f;

                frameDelta[3] = -sinZ;
                frameDelta[4] = cosZ;
                frameDelta[5] = 0.0f;

                frameDelta[6] = xAdjust;
                frameDelta[7] = yAdjust;
                frameDelta[8] = 1.0f;
            }
            if (settings.trackPosition && (status.pose & (int)GSXRPlugin.TrackingMode.kTrackingPosition) != 0)
            {
                head.transform.localPosition = headPose.position * settings.trackPositionScale;
            }
            if ((status.pose & (int)GSXRPlugin.TrackingMode.kTrackingEye) != 0)
            {
                //Debug.LogFormat("Left Eye Position: {0}, Direction: {1}", eyePose.leftPosition.ToString(), eyePose.leftDirection.ToString());
                //Debug.LogFormat("Right Eye Position: {0}, Direction: {1}", eyePose.rightPosition.ToString(), eyePose.rightDirection.ToString());
                //Debug.LogFormat("Combined Eye Position: {0}, Direction: {1}", eyePose.combinedPosition.ToString(), eyePose.combinedDirection.ToString());
                var combinedDirection = Vector3.zero;
                if ((eyePose.leftStatus & (int)GSXRPlugin.EyePoseStatus.kGazeVectorValid) != 0) combinedDirection += eyePose.leftDirection;
                if ((eyePose.rightStatus & (int)GSXRPlugin.EyePoseStatus.kGazeVectorValid) != 0) combinedDirection += eyePose.rightDirection;
                //if ((eyePose.combinedStatus & (int)GSXRPlugin.EyePoseStatus.kGazeVectorValid) != 0) combinedDirection += eyePose.combinedDirection;
                if (combinedDirection.sqrMagnitude > 0f)
                {
                    combinedDirection.Normalize();
                    //Debug.LogFormat("Eye Direction: ({0:F2}, {1:F2}, {2:F2})", combinedDirection.x, combinedDirection.y, combinedDirection.z);

                    eyeDirection = eyeSmoother > 0.001f ? Vector3.Lerp(eyeDirection, combinedDirection, eyeSmoother) : combinedDirection;

                    //var combinedPosition = Vector3.zero;
                    //if ((eyePose.leftStatus & (int)GSXRPlugin.EyePoseStatus.kGazePointValid) != 0) combinedPosition += eyePose.leftPosition;
                    //if ((eyePose.rightStatus & (int)GSXRPlugin.EyePoseStatus.kGazePointValid) != 0) combinedPosition += eyePose.rightPosition;
                    ////if ((eyePose.combinedStatus & (int)GSXRPlugin.EyePoseStatus.kGazePointValid) != 0) combinedPosition += eyePose.combinedPosition;

                    gaze.localPosition = monoCamera.transform.localPosition;
                    gaze.localRotation = Quaternion.LookRotation(eyeDirection, Vector3.up);

                    float denominator = Vector3.Dot(eyeDirection, Vector3.forward);
                    if (denominator > float.Epsilon)
                    {
                        // eye direction intersection with frustum near plane (left)
                        var eyePoint = eyeDirection * plugin.deviceInfo.targetFrustumLeft.near / denominator;

                        // size of the frustum near plane (left)
                        var nearSize = new Vector2(0.5f*(plugin.deviceInfo.targetFrustumLeft.right - plugin.deviceInfo.targetFrustumLeft.left),
                            0.5f*(plugin.deviceInfo.targetFrustumLeft.top - plugin.deviceInfo.targetFrustumLeft.bottom));

                        eyeFocus.Set(eyePoint.x / nearSize.x, eyePoint.y / nearSize.y);   // Normalized [-1,1]
                        //Debug.LogFormat("Eye Focus: {0}", eyeFocus.ToString());

                        FocalPoint = eyeFocus;  // Cache for foveated rendering
                    }
                }
            }
        }

        //var isValid = true;
        //if (settings.poseStatusFade)
        //{
        //    isValid = !settings.trackPosition
        //        || ((trackingMode & (int)GSXRPlugin.TrackingMode.kTrackingPosition) == 0)
        //        || (status.pose & (int)GSXRPlugin.TrackingMode.kTrackingPosition) != 0;
        //}

        //var targetAlpha = fadeState == eFadeState.FadeOut || !isValid ? 1f : 0f;

        var targetAlpha = fadeState == eFadeState.FadeOut ? 1f : 0f;
        UpdateOverlayFade(targetAlpha, Time.deltaTime / fadeDuration);


        if (plugin.GSXR_Is_SupportOpticsCalibration()) {
            if (leftcalib == Matrix4x4.identity || rightCalib == Matrix4x4.identity) {
                plugin.GSXR_Get_TransformMatrix(ref outBload, outTransformArray);

                if (outBload) {
                    leftcalib.SetColumn(0, new Vector4(outTransformArray[0], outTransformArray[1], outTransformArray[2], outTransformArray[3]));
                    leftcalib.SetColumn(1, new Vector4(outTransformArray[4], outTransformArray[5], outTransformArray[6], outTransformArray[7]));
                    leftcalib.SetColumn(2, new Vector4(outTransformArray[8], outTransformArray[9], outTransformArray[10], outTransformArray[11]));
                    leftcalib.SetColumn(3, new Vector4(outTransformArray[12], outTransformArray[13], outTransformArray[14], outTransformArray[15]));

                    rightCalib.SetColumn(0, new Vector4(outTransformArray[16], outTransformArray[17], outTransformArray[18], outTransformArray[19]));
                    rightCalib.SetColumn(1, new Vector4(outTransformArray[20], outTransformArray[21], outTransformArray[22], outTransformArray[23]));
                    rightCalib.SetColumn(2, new Vector4(outTransformArray[24], outTransformArray[25], outTransformArray[26], outTransformArray[27]));
                    rightCalib.SetColumn(3, new Vector4(outTransformArray[28], outTransformArray[29], outTransformArray[30], outTransformArray[31]));

                    Debug.Log($"leftcalib [{leftcalib.m00}, {leftcalib.m01}, {leftcalib.m02}, {leftcalib.m03};" +
            $"{leftcalib.m10}, {leftcalib.m11}, {leftcalib.m12}, {leftcalib.m13};" +
            $"{leftcalib.m20}, {leftcalib.m21}, {leftcalib.m22}, {leftcalib.m23};" +
            $"{leftcalib.m30}, {leftcalib.m31}, {leftcalib.m32}, {leftcalib.m33}]");

                    Debug.Log($"rightCalib [{rightCalib.m00}, {rightCalib.m01}, {rightCalib.m02}, {rightCalib.m03};" +
            $"{rightCalib.m10}, {rightCalib.m11}, {rightCalib.m12}, {rightCalib.m13};" +
            $"{rightCalib.m20}, {rightCalib.m21}, {rightCalib.m22}, {rightCalib.m23};" +
            $"{rightCalib.m30}, {rightCalib.m31}, {rightCalib.m32}, {rightCalib.m33}]");
                }
            }

            //if (outBload) {
            //    Matrix4x4 xx = leftcalib * invertZ * Matrix4x4.Inverse(Matrix4x4.TRS(leftCamera.transform.position, leftCamera.transform.rotation, leftCamera.transform.lossyScale));
            //    Matrix4x4 yy = rightCalib * invertZ * Matrix4x4.Inverse(Matrix4x4.TRS(rightCamera.transform.position, rightCamera.transform.rotation, rightCamera.transform.lossyScale));
            //    Debug.Log("SlamManager: OpticsCalibration leftCamera.worldToCameraMatrix：" + xx);
            //    Debug.Log("SlamManager: OpticsCalibration rightCamera.worldToCameraMatrix：" + yy);
            //}

            if (head.position != head.localPosition || head.rotation != head.localRotation) {
                ///for If Head parent not at origin,must mul the delta Matirx for Camera ViewMatrix
                //MD*Ml*P = Mw*P ==> MD == Mw * (M1 -1 ni)
                headDeltaInitLocalToWorld = Matrix4x4.TRS(head.position, head.rotation, Vector3.one) * Matrix4x4.Inverse(Matrix4x4.TRS(head.localPosition, head.localRotation, Vector3.one));
            }

            leftCamera.worldToCameraMatrix = plugin.leftViewMatrix * invertZ;
            leftCamera.worldToCameraMatrix = Matrix4x4.Inverse(headDeltaInitLocalToWorld * leftCamera.cameraToWorldMatrix/* not worldToCameraMatrix*/);

            rightCamera.worldToCameraMatrix = plugin.rightViewMatrix * invertZ;
            rightCamera.worldToCameraMatrix = Matrix4x4.Inverse(headDeltaInitLocalToWorld * rightCamera.cameraToWorldMatrix/* not worldToCameraMatrix*/);

            //Debug.Log("SlamManager: leftCamera.worldToCameraMatrix：" + leftCamera.worldToCameraMatrix);
            //Debug.Log("SlamManager: rightCamera.worldToCameraMatrix：" + rightCamera.worldToCameraMatrix);
        }
    }

    public void Shutdown()
	{
        Debug.Log("GSXRManager.Shutdown()");

        status.running = false;

        if (submitFrame != null) { StopCoroutine(submitFrame); submitFrame = null; }

        if (plugin.IsRunning()) plugin.EndVr();
        if (IsDontDestroyOnLoad)
        {
            if (plugin.IsInitialized()) plugin.Shutdown();
        }
       
        status.initialized = false;
    }

    void OnDestroy() {
        if (Instance != this)
            return;

        UnregisterListeners();
        // plugin.GSXR_Set_ControllerBondEventCallback(null);  //UnRegister Controller binding callback
       Shutdown();
    }

    public delegate void  OnApplicationPauseDele(bool pause);
    public static event OnApplicationPauseDele onApplicationPauseDele;
    void OnApplicationPause(bool pause)
    {
        return;
        Debug.LogFormat("GSXRManager.OnApplicationPause({0})",pause);
        if (pause)
        {
            onApplicationPauseDele?.Invoke(true);
        }
        SetPause(pause);
	}

	void OnApplicationQuit()
	{
        Debug.Log("GSXRManager.OnApplicationQuit()");
        if (!IsDontDestroyOnLoad)
        {
            Shutdown();
            if (plugin.IsInitialized()) plugin.Shutdown();
        }
       
    }

    static public Matrix4x4 Perspective(float left, float right, float bottom, float top, float near, float far)
    {
        float x = 2.0F * near / (right - left);
        float y = 2.0F * near / (top - bottom);
        float a = (right + left) / (right - left);
        float b = (top + bottom) / (top - bottom);
        float c = -(far + near) / (far - near);
        float d = -(2.0F * far * near) / (far - near);
        float e = -1.0F;
        Matrix4x4 m = new Matrix4x4();
        m[0, 0] = x;
        m[0, 1] = 0;
        m[0, 2] = a;
        m[0, 3] = 0;
        m[1, 0] = 0;
        m[1, 1] = y;
        m[1, 2] = b;
        m[1, 3] = 0;
        m[2, 0] = 0;
        m[2, 1] = 0;
        m[2, 2] = c;
        m[2, 3] = d;
        m[3, 0] = 0;
        m[3, 1] = 0;
        m[3, 2] = e;
        m[3, 3] = 0;
        return m;
    }

    void RegisterListeners()
    {
        GSXROverrideSettings.OnEyeAntiAliasingChangedEvent += OnEyeAntiAliasingChanged;
        GSXROverrideSettings.OnEyeDepthChangedEvent += OnEyeDepthChanged;
        GSXROverrideSettings.OnEyeResolutionScaleFactorChangedEvent += OnEyeResolutionScaleFactorChanged;
        GSXROverrideSettings.OnOverlayAntiAliasingChangedEvent += OnOverlayAntiAliasingChanged;
        GSXROverrideSettings.OnOverlayDepthChangedEvent += OnOverlayDepthChanged;
        GSXROverrideSettings.OnOverlayResolutionScaleFactorChangedEvent += OnOverlayResolutionScaleFactorChanged;
        GSXROverrideSettings.OnChromaticAberrationCorrectionChangedEvent += OnChromaticAberrationCorrectionChanged;
        GSXROverrideSettings.OnVSyncCountChangedEvent += OnVSyncCountChanged;
        GSXROverrideSettings.OnMasterTextureLimitChangedEvent += OnMasterTextureLimitChanged;
        GSXROverrideSettings.OnPerfLevelChangedEvent += OnPerfLevelChanged;
        GSXROverrideSettings.OnFoveateChangedEvent += OnFoveateChanged;
    }
	
    void UnregisterListeners()
    {
        GSXROverrideSettings.OnEyeAntiAliasingChangedEvent -= OnEyeAntiAliasingChanged;
        GSXROverrideSettings.OnEyeDepthChangedEvent -= OnEyeDepthChanged;
        GSXROverrideSettings.OnEyeResolutionScaleFactorChangedEvent -= OnEyeResolutionScaleFactorChanged;
        GSXROverrideSettings.OnOverlayAntiAliasingChangedEvent -= OnOverlayAntiAliasingChanged;
        GSXROverrideSettings.OnOverlayDepthChangedEvent -= OnOverlayDepthChanged;
        GSXROverrideSettings.OnOverlayResolutionScaleFactorChangedEvent -= OnOverlayResolutionScaleFactorChanged;
        GSXROverrideSettings.OnChromaticAberrationCorrectionChangedEvent -= OnChromaticAberrationCorrectionChanged;
        GSXROverrideSettings.OnVSyncCountChangedEvent -= OnVSyncCountChanged;
        GSXROverrideSettings.OnMasterTextureLimitChangedEvent -= OnMasterTextureLimitChanged;
        GSXROverrideSettings.OnPerfLevelChangedEvent -= OnPerfLevelChanged;
        GSXROverrideSettings.OnFoveateChangedEvent -= OnFoveateChanged;
    }

    void OnEyeAntiAliasingChanged(GSXROverrideSettings.eAntiAliasing antiAliasing)
    {
        foreach (GSXREye eye in eyes)
        {
            eye.AntiAliasing = antiAliasing == GSXROverrideSettings.eAntiAliasing.NoOverride ? 
                (int)settings.eyeAntiAliasing : (int)antiAliasing;
        }
    }
	
    void OnEyeDepthChanged(GSXROverrideSettings.eDepth depth)
    {
        foreach (GSXREye eye in eyes)
        {
            eye.Depth = depth == GSXROverrideSettings.eDepth.NoOverride ?
                (int)settings.eyeDepth : (int)depth;
        }
    }
	
    void OnEyeResolutionScaleFactorChanged(float scaleFactor)
    {
        foreach (GSXREye eye in eyes)
        {
            eye.ResolutionScaleFactor = scaleFactor <= 0 ? settings.eyeResolutionScaleFactor : scaleFactor;
        }
    }
	
    void OnOverlayAntiAliasingChanged(GSXROverrideSettings.eAntiAliasing antiAliasing)
    {
        foreach (GSXROverlay overlay in overlays)
        {
            overlay.AntiAliasing = antiAliasing == GSXROverrideSettings.eAntiAliasing.NoOverride ?
                (int)settings.overlayAntiAliasing : (int)antiAliasing;
        }
    }
	
    void OnOverlayDepthChanged(GSXROverrideSettings.eDepth depth)
    {
        foreach (GSXROverlay overlay in overlays)
        {
            overlay.Depth = depth == GSXROverrideSettings.eDepth.NoOverride ?
                (int)settings.overlayDepth : (int)depth;
        }
    }
	
    void OnOverlayResolutionScaleFactorChanged(float scaleFactor)
    {
        foreach (GSXROverlay overlay in overlays)
        {
            overlay.ResolutionScaleFactor = scaleFactor <= 0 ? settings.overlayResolutionScaleFactor : scaleFactor;
        }
    }
	
    void OnChromaticAberrationCorrectionChanged(GSXROverrideSettings.eChromaticAberrationCorrection aberrationCorrection)
    {
        if(aberrationCorrection == GSXROverrideSettings.eChromaticAberrationCorrection.kDisable)
        {
            plugin.SetFrameOption(GSXRPlugin.FrameOption.kDisableChromaticCorrection);
        }
        else
        {
            plugin.UnsetFrameOption(GSXRPlugin.FrameOption.kDisableChromaticCorrection);
        }
    }
	
    void OnVSyncCountChanged(GSXROverrideSettings.eVSyncCount vSyncCount)
    {
        if (vSyncCount == GSXROverrideSettings.eVSyncCount.NoOverride)
        {
            plugin.SetVSyncCount((int)settings.vSyncCount);
            QualitySettings.vSyncCount = (int)settings.vSyncCount;
        }
        else
        {
            plugin.SetVSyncCount((int)vSyncCount);
            QualitySettings.vSyncCount = (int)settings.vSyncCount;
        }
    }
	
    void OnMasterTextureLimitChanged(GSXROverrideSettings.eMasterTextureLimit masterTextureLimit)
    {
        QualitySettings.globalTextureMipmapLimit = masterTextureLimit == GSXROverrideSettings.eMasterTextureLimit.NoOverride ? 
            (int)settings.masterTextureLimit : (int)masterTextureLimit;
    }
	
    void OnPerfLevelChanged(GSXROverrideSettings.ePerfLevel cpuPerfLevel, GSXROverrideSettings.ePerfLevel gpuPerfLevel)
    {
        int currentCpuPerfLevel = cpuPerfLevel == GSXROverrideSettings.ePerfLevel.NoOverride ? 
            (int)settings.cpuPerfLevel : (int)GSXROverrideSettings.CpuPerfLevel;
        int currentGpuPerfLevel = gpuPerfLevel == GSXROverrideSettings.ePerfLevel.NoOverride ?
            (int)settings.gpuPerfLevel : (int)GSXROverrideSettings.GpuPerfLevel;
        plugin.SetPerformanceLevels(currentCpuPerfLevel, currentGpuPerfLevel);
    }

    void OnFoveateChanged(Vector2 gain, float area, float minPixelDensity)
    {
        var point = Vector2.zero;
        var currentGain = gain == Vector2.zero ?
            settings.foveationGain : GSXROverrideSettings.FoveateGain;
        var currentArea = area == 0f ?
            settings.foveationArea : GSXROverrideSettings.FoveateArea;
        var currentMinimum = minPixelDensity == 0f ?
            settings.foveationMinimum : GSXROverrideSettings.FoveateMinimum;
        plugin.SetFoveationParameters(0, 0, point.x, point.y, currentGain.x, currentGain.y, currentArea, currentMinimum);
    }

	/// <summary>
	/// Update this instance.
	/// </summary>
	//---------------------------------------------------------------------------------------------
	void Update()
	{
		SlamEvent frameEvent = new SlamEvent ();

        while (plugin.PollEvent(ref frameEvent))
		{
            //Debug.LogFormat("SlamEvent: {0}", frameEvent.eventType.ToString());
            for (int i = 0; i < eventListeners.Count; i++) {
				eventListeners [i].OnSlamEvent (frameEvent);
			}
		}
	}

	/// <summary>
	/// Adds the event listener.
	/// </summary>
	/// <param name="listener">Listener.</param>
	//---------------------------------------------------------------------------------------------
	public void AddEventListener(SlamEventListener listener)
	{
		if (listener != null) {
			eventListeners.Insert (0, listener);
		}
	}
    
	/// <summary>
	/// Start Tracking
	/// </summary>
	/// <returns>Handle to the controller</returns>
	/// <param name="desc">Desc.</param>
	//---------------------------------------------------------------------------------------------
    public int ControllerStartTracking(string desc)
    {
        return plugin.ControllerStartTracking(desc);
    }
    
	/// <summary>
	/// Stop Tracking
	/// </summary>
	/// <param name="handle">Handle.</param>
	//---------------------------------------------------------------------------------------------
	public void ControllerStopTracking(int handle)
    {
        plugin.ControllerStopTracking(handle);
    }
    
	/// <summary>
	/// Get current state
	/// </summary>
	/// <returns>Controller State.</returns>
	/// <param name="handle">Handle.</param>
	//---------------------------------------------------------------------------------------------
	public GSXRControllerState ControllerGetState(int handle, int space = 0)
    {
		return plugin.ControllerGetState(handle, space);
    }

	/// <summary>
	/// Send an event to the controller
	/// </summary>
	/// <param name="handle">Handle.</param>
	/// <param name="what">What.</param>
	/// <param name="arg1">Arg1.</param>
	/// <param name="arg2">Arg2.</param>
	//---------------------------------------------------------------------------------------------
	public void ControllerSendMessage(int handle, GSXRController.slamControllerMessageType what, int arg1, int arg2)
	{
		plugin.ControllerSendMessage (handle, what, arg1, arg2);
	}

	/// <summary>
	/// Controllers the query.
	/// </summary>
	/// <returns>The query.</returns>
	/// <param name="handle">Handle.</param>
	/// <param name="what">What.</param>
	/// <param name="mem">Mem.</param>
	/// <param name="size">Size.</param>
	//---------------------------------------------------------------------------------------------
	public object ControllerQuery(int handle, GSXRController.slamControllerQueryType what)
	{
		return plugin.ControllerQuery (handle, what);
	}




    Coroutine startSlameCor;
    public void StartSlam() {
        if (startSlameCor == null) {
            Debug.Log("StartSlam Coroutine Start");
            startSlameCor = StartCoroutine(startSlam());
        } else {
            Debug.Log("startSlame Coroutine Not Null");
        }
    }

    IEnumerator startSlam() {
        yield return new WaitUntil(() => GSXRManager.Instance != null);

        yield return new WaitUntil(() => !GSXRManager.Instance.IsRunning);
        GSXRManager.Instance.SetPause(false);
        yield return new WaitUntil(() => IsTrackingValid);

        startSlameCor = null;
    }


    Coroutine stopSlameCor;

    //when stopSlam you must be sure no StartCorutine run before!
    public void StopSlam() {
        if (stopSlameCor == null && startSlameCor == null) {
            Debug.Log("stopSlame Coroutine Start");
            stopSlameCor = StartCoroutine(stopSlam());
        } else if (stopSlameCor != null) {
            Debug.Log("stopSlame Coroutine Not Null");
        } else if (startSlameCor != null) {
            Debug.Log("stopSlame: startSlame Coroutine Not Null");
        }
    }

    IEnumerator stopSlam() {
        yield return new WaitUntil(() => GSXRManager.Instance != null);
        yield return new WaitUntil(() => GSXRManager.Instance.IsRunning);

        GSXRManager.Instance.SetPause(true);
        yield return new WaitUntil(() => !GSXRManager.Instance.IsRunning);

        stopSlameCor = null;
    }



    Coroutine resetSlameCor;
    public void ResetSlam() {
        if (resetSlameCor == null) {
            Debug.Log("resetSlameCor Coroutine Start");
            resetSlameCor = StartCoroutine(resetSlam());
        } else {
            Debug.Log("resetSlameCor Coroutine Not Null");
        }
    }

    IEnumerator resetSlam() {

        Debug.Log("ResetSlam Coroutine Step 0: CheckFlag...");

        yield return new WaitUntil(() => GSXRManager.Instance != null);
        yield return new WaitUntil(() => GSXRManager.Instance.IsRunning);
        Debug.Log("ResetSlam Coroutine Step 1: StopSlam");
        GSXRManager.Instance.SetPause(true);

        yield return new WaitUntil(() => !GSXRManager.Instance.IsRunning);
        Debug.Log("ResetSlam Coroutine Step 2: StartSlam");
        GSXRManager.Instance.SetPause(false);
        yield return new WaitUntil(() => IsTrackingValid);

        Debug.Log("ResetSlam Coroutine Finish");
        resetSlameCor = null;
    }


    public bool IsTrackingValid {
        get {
            if (GSXRManager.Instance && GSXRManager.Instance.IsRunning) {
                return !GSXRManager.Instance.settings.trackPosition
                || ((GSXRManager.Instance.plugin.GetTrackingMode() & (int)GSXRPlugin.TrackingMode.kTrackingPosition) == 0)
                || (GSXRManager.Instance.status.pose & (int)GSXRPlugin.TrackingMode.kTrackingPosition) != 0;
            }
            return false;
        }
    }

    public Shoulder shoulder;

    public class Shoulder {

        public Transform Left { get; private set; }
        public Transform Right { get; private set; }

        private Transform head;
        private Vector3 leftOffset;
        public Shoulder(Transform head,Vector3 leftOffset) {
            this.head = head;
            this.leftOffset = leftOffset;

            if (head) {
                Left = new GameObject("LeftShoulder").transform;
                Left.SetParent(head,false);
                Left.localPosition = leftOffset;

                Right = new GameObject("RightShoulder").transform;
                Right.SetParent(head, false);
                Right.localPosition = new Vector3(-leftOffset.x, leftOffset.y, leftOffset.z) ;
            }

        }

    }

    public void GSXR_Set_OnFloorOrOnHead(int type)
    {
        if (type != 0 && type != 1)
        {
            DebugMy.Log("GSXR_Set_OnFloorOrOnHead: index Must 1 or 0", this, true);
            return ;
        }
        plugin.GSXR_Set_OnFloorOrOnHead(type);
    }



    Coroutine VibrateCoroutine0, VibrateCoroutine1;
    public void GSXR_Set_ControllerVibrate(int index,bool isOn, VibrateOnType vibrateOnType, float time) {
        if (index != 0 && index != 1) { 
            DebugMy.Log("GSXR_Set_ControllerVibrate: index Must 1 or 0", this, true);
            return;
        }

        if (vibrateOnType == VibrateOnType.Null) {
            //DebugMy.Log("GSXR_Set_ControllerVibrate: vibrateOnType Null", this, true);
            return;
        }

        //DebugMy.Log("GSXR_Set_ControllerVibrate:" + index + " " + isOn + " " + vibrateOnType + " " + time, this, true);

        if (index == 0 && VibrateCoroutine0 != null) {
            StopCoroutine(VibrateCoroutine0);
            VibrateCoroutine0 = null;
        } else if (index == 1 && VibrateCoroutine1 != null) {
            StopCoroutine(VibrateCoroutine1);
            VibrateCoroutine1 = null;
        }

        if (isOn) {
            if (index == 0) {
                VibrateCoroutine0 = StartCoroutine(VibrateRun(index, vibrateOnType, time));
            } else if (index == 1) {
                VibrateCoroutine1 = StartCoroutine(VibrateRun(index, vibrateOnType, time));
            }
        } else {
            plugin.GSXR_Set_ControllerVibrate(index, false);
        }
    }


    public int GSXR_Set_ControllerVibrate(int index, bool isOn, float amplitude, float frequency, float time)
    {
        if (index != 0 && index != 1 && index != 2)
        {
            DebugMy.Log("GSXR_Set_ControllerVibrateStatus: index Must 2 or 1 or 0", this, true);
            return -1;
        }
        int amplitude1 = Convert.ToInt32(Math.Ceiling(amplitude * 16));
        int frequency1 = Convert.ToInt32(Math.Ceiling(frequency * 16));
        int time1 = Convert.ToInt32(Math.Round(time * 10));
        //Debug.Log("KMSet_ControllerVibrate: "+index+","+isOn+","+amplitude1+","+ frequency1+","+ time1);
        return plugin.GSXR_Set_ControllerVibrate(index, isOn, amplitude1, frequency1, time1);
    }

    public bool GSXR_Get_ControllerVibrateStatus(int index)
    {
        if (index != 0 && index != 1)
        {
            DebugMy.Log("GSXR_Get_ControllerVibrateStatus: index Must 1 or 0", this, true);
            return false;
        }
        return plugin.GSXR_Get_ControllerVibrateStatus(index);
    }


    public int GSXR_Get_ControllerVibrateState(int index)
    {
        if (index != 0 && index != 1 && index != 2)
        {
            DebugMy.Log("GSXR_Get_ControllerVibrateState: index Must 2 or 1 or 0", this, true);
            return -1;
        }
        return ((plugin.GSXR_Get_ControllerVibrateState(index) >> 2) & 1);
    }
    public enum VibrateOnType {
        Shutdown,
        OneShot,
        Continuous,
        OneShotContinuous,
        Null,
    }

    IEnumerator VibrateRun(int index, VibrateOnType vibrateOnType, float time) {
        yield return null;

        if (vibrateOnType == VibrateOnType.OneShot) {

            plugin.GSXR_Set_ControllerVibrate(index, true);
            yield return new WaitForSeconds(time);
            plugin.GSXR_Set_ControllerVibrate(index, false);

        } else if (vibrateOnType == VibrateOnType.Continuous) {
            plugin.GSXR_Set_ControllerVibrate(index, true);
            while (true) {
                yield return null;
            }
        } else if (vibrateOnType == VibrateOnType.OneShotContinuous) {
            while (true) {
                plugin.GSXR_Set_ControllerVibrate(index, true);
                yield return new WaitForSeconds(time);
                plugin.GSXR_Set_ControllerVibrate(index, false);
                yield return new WaitForSeconds(time / 2);
            }
        } else if (vibrateOnType == VibrateOnType.Shutdown) {
            plugin.GSXR_Set_ControllerVibrate(index, false);
        }
        if (index == 0) {
            VibrateCoroutine0 = null;
        } else if (index == 1) {
            VibrateCoroutine1 = null;
        }
    }

    public int GSXR_Get_ControllerAccelerometer(float[] orientationArray, int index) {
        if (index != 0 && index != 1)
        {
            DebugMy.Log("GSXR_Get_ControllerAccelerometer: index Must 1 or 0", this, true);
            return -4;
        }
        return plugin.GSXR_Get_ControllerAccelerometer(orientationArray, index); 
    }

    public int GSXR_Get_ControllerGyroscope(float[] orientationArray, int index) {
        if (index != 0 && index != 1)
        {
            DebugMy.Log("GSXR_Get_ControllerGyroscope: index Must 1 or 0", this, true);
            return -4;
        }
        return GSXR_Get_ControllerGyroscope(orientationArray, index); 
    }
    public int GSXR_Get_ControllerAngleVelocity(float[] orientationArray, int index)
    {
        if (index != 0 && index != 1)
        {
            DebugMy.Log("GSXR_Get_ControllerAngleVelocity: index Must 1 or 0", this, true);
            return -4;
        }
        return plugin.GSXR_Get_ControllerAngleVelocity(orientationArray, index);
    }

    public int GSXR_Get_ControllerLinearVelocity(float[] orientationArray, int index)
    {
        if (index != 0 && index != 1)
        {
            DebugMy.Log("GSXR_Get_ControllerLinearVelocity: index Must 1 or 0", this, true);
            return -4;
        }
        return plugin.GSXR_Get_ControllerLinearVelocity(orientationArray, index);
    }
    public void GSXR_Bind_Controller(int index, int type) {
        if (index != 0 && index != 1)
        {
            DebugMy.Log("GSXR_Bind_Controller: index Must 1 or 0", this, true);
            return;
        }       
        plugin.GSXR_Bind_Controller(index, type);
    }

    public void GSXR_Unbind_Controller(int index, int type) {
        if (index != 0 && index != 1)
        {
            DebugMy.Log("GSXR_Unbind_Controller: index Must 1 or 0", this, true);
            return;
        }
       plugin.GSXR_Unbind_Controller(index, type); 
    }

    public int GSXR_Get_ControllerBondState()
    {
        return plugin.GSXR_Get_ControllerBondState();
    }

    public void GSXR_Set_ControllerBondEventCallback(bool isEnable)
    {
        if (isEnable)
        {
            plugin.GSXR_Set_ControllerBondEventCallback(ControllerBondStateCallBack);
        }
        else
        {
            plugin.GSXR_Set_ControllerBondEventCallback(null);
        }

    }
    [MonoPInvokeCallback(typeof(Action<int>))]
    private static void ControllerBondStateCallBack(int bondState)
    {
        if (OnBondStateEvent != null && OnBondStateEvent.GetInvocationList().Length != 0)
        {
            OnBondStateEvent(bondState);
        }
    }

    private static Action<int> OnBondStateEvent;
    public void GSXR_Add_ControllerBondEventCallback(Action<int> callback)   //Register the Controller binding status callback
    {
        OnBondStateEvent += callback;
    }

    public void GSXR_Remove_ControllerBondEventCallback(Action<int> callback)  //UnRegister the Controller binding status callback
    {
        OnBondStateEvent -= callback;
    }


}