/// <summary>
/// Return the predicted display time as a leap time
/// </summary>
/// <returns></returns>
private long GetPredictedDisplayTime_LeapTime()
{
long leapClock = 0;
// Predicted display time for the current frame in milliseconds
float displayTime_ms = SxrShim.GetPredictedDisplayTime(SystemInfo.graphicsMultiThreaded);
if (_clockRebaser != IntPtr.Zero)
{
LeapC.RebaseClock(_clockRebaser, (long)displayTime_ms + _stopwatch.ElapsedMilliseconds, out leapClock);
}
return(leapClock);
}
private void InitClockRebaser()
{
_stopwatch.Start();
eLeapRS result = LeapC.CreateClockRebaser(out _clockRebaser);
if (result != eLeapRS.eLeapRS_Success)
{
Debug.LogError("Failed to create clock rebaser");
}
if (_clockRebaser == IntPtr.Zero)
{
Debug.LogError("Clock rebaser is null");
}
}
public void TestCreateDestroyWithConfigRequest()
{
IntPtr connHandle = IntPtr.Zero;
int iterations = 5000;
uint requestId;
for (int i = 0; i < iterations; i++)
{
//LEAP_CONNECTION_MESSAGE msg = new LEAP_CONNECTION_MESSAGE();
LeapC.CreateConnection(out connHandle);
LeapC.OpenConnection(connHandle);
LeapC.RequestConfigValue(connHandle, "tracking_version", out requestId);
LeapC.DestroyConnection(connHandle);
}
}
/// <summary>
/// Stops the connection for the existing instance of a Controller, clearing old
/// policy flags and resetting the Controller to null.
/// </summary>
public void destroyController()
{
if (_leapController != null)
{
_leapController.StopConnection();
_leapController.Dispose();
_leapController = null;
#if SVR
if (_clockRebaser != IntPtr.Zero)
{
LeapC.DestroyClockRebaser(_clockRebaser);
_stopwatch.Stop();
}
#endif
}
}
/// <summary>
/// Returns the internal status field of the current device
/// </summary>
protected uint GetDeviceStatus()
{
eLeapRS result;
LEAP_DEVICE_INFO deviceInfo = new LEAP_DEVICE_INFO();
deviceInfo.serial = IntPtr.Zero;
deviceInfo.size = (uint)System.Runtime.InteropServices.Marshal.SizeOf(deviceInfo);
result = LeapC.GetDeviceInfo(InternalHandle, ref deviceInfo);
if (result != eLeapRS.eLeapRS_Success)
{
return(0);
}
uint status = deviceInfo.status;
System.Runtime.InteropServices.Marshal.FreeCoTaskMem(deviceInfo.serial);
return(status);
}
public bool SetPaused(bool pause)
{
ulong prior_state = 0;
ulong set_flags = 0;
ulong clear_flags = 0;
if (pause)
{
set_flags = (ulong)eLeapDeviceFlag.eLeapDeviceFlag_Stream;
}
else
{
clear_flags = (ulong)eLeapDeviceFlag.eLeapDeviceFlag_Stream;
}
eLeapRS result = LeapC.SetDeviceFlags(Handle, set_flags, clear_flags, out prior_state);
return(result == eLeapRS.eLeapRS_Success);
}
/**
* Returns a timestamp value as close as possible to the current time.
* Values are in microseconds, as with all the other timestamp values.
*
* @since 2.2.7
*
*/
public long Now()
{
return(LeapC.GetNow());
}
public UInt64 TelemetryGetNow()
{
return(LeapC.TelemetryGetNow());
}
public bool SetPaused(bool pause)
{
eLeapRS result = LeapC.LeapSetPause(Handle, pause);
return(result == eLeapRS.eLeapRS_Success);
}
protected virtual void Update()
{
if (_workerThreadProfiling)
{
LeapProfiling.Update();
}
if (!checkConnectionIntegrity())
{
return;
}
#if UNITY_EDITOR
if (UnityEditor.EditorApplication.isCompiling)
{
UnityEditor.EditorApplication.isPlaying = false;
Debug.LogWarning("Unity hot reloading not currently supported. Stopping Editor Playback.");
return;
}
#endif
_fixedOffset.Update(Time.time - Time.fixedTime, Time.deltaTime);
if (_frameOptimization == FrameOptimizationMode.ReusePhysicsForUpdate)
{
DispatchUpdateFrameEvent(_transformedFixedFrame);
return;
}
#if SVR
if (_clockRebaser != IntPtr.Zero)
{
eLeapRS result = LeapC.UpdateRebase(_clockRebaser, _stopwatch.ElapsedMilliseconds, LeapC.GetNow());
if (result != eLeapRS.eLeapRS_Success)
{
Debug.LogWarning("UpdateRebase call failed");
}
}
#endif
if (_useInterpolation)
{
#if !UNITY_ANDROID || UNITY_EDITOR
_smoothedTrackingLatency.value = Mathf.Min(_smoothedTrackingLatency.value, 30000f);
_smoothedTrackingLatency.Update((float)(_leapController.Now() - _leapController.FrameTimestamp()), Time.deltaTime);
#endif
long timestamp = CalculateInterpolationTime() + (ExtrapolationAmount * 1000);
_unityToLeapOffset = timestamp - (long)(Time.time * S_TO_NS);
_leapController.GetInterpolatedFrameFromTime(_untransformedUpdateFrame, timestamp, CalculateInterpolationTime() - (BounceAmount * 1000));
}
else
{
_leapController.Frame(_untransformedUpdateFrame);
}
if (_untransformedUpdateFrame != null)
{
transformFrame(_untransformedUpdateFrame, _transformedUpdateFrame);
DispatchUpdateFrameEvent(_transformedUpdateFrame);
}
}
/**
* Updates the estimate of latency between render time
* and the Leap Motion device time.
*
* Call this function when a frame is rendered.
*
* @param externalClockTime The time in milliseconds when the graphics frame is rendered.
* @param leapClock the time in milliseconds obtained by calling Controller.Now().
* @since 3.x.z
*/
public void UpdateRebaseEstimate(Int64 applicationClock, Int64 leapClock)
{
LeapC.UpdateRebase(_rebaserHandle, applicationClock, leapClock);
}
/**
* Updates the estimate of latency between render time
* and the Leap Motion device time.
*
* Call this function when a frame is rendered. Uses the leap clock time
* at the moment this function is called.
*
* @param externalClockTime The time in milliseconds when the graphics frame is rendered.
* @since 3.x.z
*/
public void UpdateRebaseEstimate(Int64 applicationClock)
{
LeapC.UpdateRebase(_rebaserHandle, applicationClock, LeapC.GetNow());
}
