public OpenVREventArgs(VREvent_t rawEvent)
 {
     EventType = (EVREventType)rawEvent.eventType;
     DeviceIndex = (int)rawEvent.trackedDeviceIndex;
     Age = rawEvent.eventAgeSeconds;
     EventData = rawEvent.data;
 }

    public bool PollNextEvent(ref VREvent_t pEvent)
    {
        var overlay = OpenVR.Overlay;
        if (overlay == null)
            return false;

        var size = (uint)System.Runtime.InteropServices.Marshal.SizeOf(typeof(Valve.VR.VREvent_t));
        return overlay.PollNextOverlayEvent(handle, ref pEvent, size);
    }

 public bool PollNextEvent(ref VREvent_t pEvent)
 {
     CVROverlay overlay = OpenVR.Overlay;
     if (overlay == null)
     {
         return false;
     }
     uint uncbVREvent = (uint)Marshal.SizeOf(typeof(VREvent_t));
     return overlay.PollNextOverlayEvent(this.handle, ref pEvent, uncbVREvent);
 }

	public abstract bool PollNextOverlayEvent(ulong ulOverlayHandle,ref VREvent_t pEvent);

	public abstract bool PollNextEventWithPose(ETrackingUniverseOrigin eOrigin,ref VREvent_t pEvent,ref TrackedDevicePose_t pTrackedDevicePose);

	public abstract bool PollNextEvent(ref VREvent_t pEvent);

	internal static extern bool VR_IVROverlay_PollNextOverlayEvent(IntPtr instancePtr, ulong ulOverlayHandle, ref VREvent_t pEvent);

	public bool PollNextOverlayEvent(ulong ulOverlayHandle,ref VREvent_t pEvent,uint uncbVREvent)
	{
		bool result = FnTable.PollNextOverlayEvent(ulOverlayHandle,ref pEvent,uncbVREvent);
		return result;
	}

	public bool PollNextEventWithPose(ETrackingUniverseOrigin eOrigin,ref VREvent_t pEvent,uint uncbVREvent,ref TrackedDevicePose_t pTrackedDevicePose)
	{
		bool result = FnTable.PollNextEventWithPose(eOrigin,ref pEvent,uncbVREvent,ref pTrackedDevicePose);
		return result;
	}

	public bool PollNextEvent(ref VREvent_t pEvent,uint uncbVREvent)
	{
		bool result = FnTable.PollNextEvent(ref pEvent,uncbVREvent);
		return result;
	}

 static void PollOverlayEvents(ulong handle)
 {
     if (m_cvrOverlay.HandleControllerOverlayInteractionAsMouse(handle, m_controller2ID))
     {
         //controller points to the overlay and event was generated. Unsure if the call above must be called every tick to generate event
         VREvent_t oEvent=new VREvent_t();
         uint oEventSize=(uint)Marshal.SizeOf(oEvent);
         while( m_cvrOverlay.PollNextOverlayEvent(handle,ref oEvent, oEventSize))
         {
             Log.WriteLineAndConsole("OVERLAY event (#"+oEvent.trackedDeviceIndex+"): " + oEvent.eventType.ToString() + " " + Enum.GetName(typeof(EVREventType), oEvent.eventType));
             switch(oEvent.eventType)
             {
                 case (uint)EVREventType.VREvent_MouseMove:
                     if (oEvent.trackedDeviceIndex==m_controller2ID)
                         Log.WriteLineAndConsole("  " + oEvent.data.mouse.x + "," + oEvent.data.mouse.y);
                     break;
             }
         }
     };
 }

 public bool PollNextEvent(ref VREvent_t pEvent)
 {
     var vr = SteamVR.instance;
     return vr.overlay.PollNextOverlayEvent(handle, ref pEvent);
 }

	internal static extern bool VR_IVRSystem_PollNextEvent(IntPtr instancePtr, ref VREvent_t pEvent);

    void Update()
    {
        if (cameras.Length == 0)
        {
            enabled = false;
            return;
        }

        // Force controller update in case no one else called this frame to ensure prevState gets updated.
        SteamVR_Controller.Update();

        // Dispatch any OpenVR events.
        var vr = SteamVR.instance;
        var vrEvent = new VREvent_t();
        for (int i = 0; i < 64; i++)
        {
            if (!vr.hmd.PollNextEvent(ref vrEvent))
                break;

            switch ((EVREventType)vrEvent.eventType)
            {
                case EVREventType.VREvent_InputFocusCaptured: // another app has taken focus (likely dashboard)
                    SteamVR_Utils.Event.Send("input_focus", false);
                    break;
                case EVREventType.VREvent_InputFocusReleased: // that app has released input focus
                    SteamVR_Utils.Event.Send("input_focus", true);
                    break;
                default:
                    var name = System.Enum.GetName(typeof(EVREventType), vrEvent.eventType);
                    if (name != null)
                        SteamVR_Utils.Event.Send(name.Substring(8) /*strip VREvent_*/, vrEvent);
                    break;
            }
        }

        // Ensure various settings to minimize latency.
        Application.targetFrameRate = -1;
        Application.runInBackground = true; // don't require companion window focus
        QualitySettings.maxQueuedFrames = -1;
        QualitySettings.vSyncCount = 0; // this applies to the companion window
        Time.fixedDeltaTime = 1.0f / vr.hmd_DisplayFrequency;
    }

	internal static extern bool VR_IVRSystem_PollNextEventWithPose(IntPtr instancePtr, ETrackingUniverseOrigin eOrigin, ref VREvent_t pEvent, ref TrackedDevicePose_t pTrackedDevicePose);

    void Update()
    {
        #if !(UNITY_5_3 || UNITY_5_2 || UNITY_5_1 || UNITY_5_0)
        if (poseUpdater == null)
        {
            var go = new GameObject("poseUpdater");
            go.transform.parent = transform;
            poseUpdater = go.AddComponent<SteamVR_UpdatePoses>();
        }
        #else
        if (cameras.Length == 0)
        {
            enabled = false;
            return;
        }

        // If our FixedUpdate rate doesn't match our render framerate, then catch the handoff here.
        SteamVR_Utils.QueueEventOnRenderThread(SteamVR.Unity.k_nRenderEventID_PostPresentHandoff);
        #endif
        // Force controller update in case no one else called this frame to ensure prevState gets updated.
        SteamVR_Controller.Update();

        // Dispatch any OpenVR events.
        var system = OpenVR.System;
        if (system != null)
        {
            var vrEvent = new VREvent_t();
            var size = (uint)System.Runtime.InteropServices.Marshal.SizeOf(typeof(VREvent_t));
            for (int i = 0; i < 64; i++)
            {
                if (!system.PollNextEvent(ref vrEvent, size))
                    break;

                switch ((EVREventType)vrEvent.eventType)
                {
                    case EVREventType.VREvent_InputFocusCaptured: // another app has taken focus (likely dashboard)
                        if (vrEvent.data.process.oldPid == 0)
                        {
                            SteamVR_Utils.Event.Send("input_focus", false);
                        }
                        break;
                    case EVREventType.VREvent_InputFocusReleased: // that app has released input focus
                        if (vrEvent.data.process.pid == 0)
                        {
                            SteamVR_Utils.Event.Send("input_focus", true);
                        }
                        break;
                    case EVREventType.VREvent_ShowRenderModels:
                        SteamVR_Utils.Event.Send("hide_render_models", false);
                        break;
                    case EVREventType.VREvent_HideRenderModels:
                        SteamVR_Utils.Event.Send("hide_render_models", true);
                        break;
                    default:
                        var name = System.Enum.GetName(typeof(EVREventType), vrEvent.eventType);
                        if (name != null)
                            SteamVR_Utils.Event.Send(name.Substring(8) /*strip VREvent_*/, vrEvent);
                        break;
                }
            }
        }

        // Ensure various settings to minimize latency.
        Application.targetFrameRate = -1;
        Application.runInBackground = true; // don't require companion window focus
        QualitySettings.maxQueuedFrames = -1;
        QualitySettings.vSyncCount = 0; // this applies to the companion window

        if (lockPhysicsUpdateRateToRenderFrequency && Time.timeScale > 0.0f)
        {
            var vr = SteamVR.instance;
            if (vr != null)
            {
                var timing = new Compositor_FrameTiming();
                timing.m_nSize = (uint)System.Runtime.InteropServices.Marshal.SizeOf(typeof(Compositor_FrameTiming));
                vr.compositor.GetFrameTiming(ref timing, 0);

                Time.fixedDeltaTime = Time.timeScale / vr.hmd_DisplayFrequency;
                Time.maximumDeltaTime = Time.fixedDeltaTime * timing.m_nNumFramePresents;
            }
        }
    }

 private void PollEvents(object stateIgnored)
 {
     VREvent_t vrEvent = new VREvent_t();
     while (hmd.PollNextEvent(ref vrEvent, (uint)Marshal.SizeOf<VREvent_t>()))
     {
         OpenVREvent?.Invoke(this, new OpenVREventArgs(vrEvent));
     }
 }