private Quaternion calculateRotation(LeapTransform trs)
{
Vector3 up = trs.yBasis.ToVector3();
Vector3 forward = trs.zBasis.ToVector3();
return(Quaternion.LookRotation(forward, up));
}
private void GenerateFrame()
{
hands.Clear();
LeapTransform leapTransform = new LeapTransform(Vector.Zero, LeapQuaternion.Identity, Vector.Ones);
/*if (rightControllerHand != null && rightControllerHand.IsActive) hands.Add(rightControllerHand.GenerateHandData(frameID).Transform(leapTransform));
* if (leftControllerHand != null && leftControllerHand.IsActive) hands.Add(leftControllerHand.GenerateHandData(frameID).Transform(leapTransform));*/
if (rightControllerHand != null && rightControllerHand.IsActive)
{
hands.Add(rightControllerHand.LeapHand.Transform(leapTransform));
}
if (leftControllerHand != null && leftControllerHand.IsActive)
{
hands.Add(leftControllerHand.LeapHand.Transform(leapTransform));
}
//currentFrame = new Leap.Frame(frameID, timeStamp, 60, hands);
currentFrame.Id = frameID;
currentFrame.Timestamp = timeStamp;
//frame.Hands = hands;
frameID++;
timeStamp++;
}
protected void transformFrame(Frame source, Frame dest, bool resampleTemporalWarping = true)
{
LeapTransform leapTransform;
if (_temporalWarping != null)
{
if (resampleTemporalWarping)
{
_temporalWarping.TryGetWarpedTransform(LeapVRTemporalWarping.WarpedAnchor.CENTER, out warpedPosition, out warpedRotation, source.Timestamp);
warpedRotation = warpedRotation * transform.localRotation;
}
leapTransform = new LeapTransform(warpedPosition.ToVector(), warpedRotation.ToLeapQuaternion(), transform.lossyScale.ToVector() * 1e-3f);
leapTransform.MirrorZ();
}
else
{
leapTransform = transform.GetLeapMatrix();
}
// My Modifications Start--->
// leapTransform.MirrorX();
//leapTransform.translation = new Vector(0.5f,0.6f,0.7f);
// My Modifications End--->
dest.CopyFrom(source).Transform(leapTransform);
}
/**
* Converts a LeapTransform representing a rotation to a Unity Quaternion without
* depending on the LeapTransform having a valid Quaternion.
*
* In previous version prior 4.0.0 this function performed a conversion to Unity's left-handed coordinate system, and now does not.
*
* @returns A Unity Quaternion representing the rotation.
*/
public static Quaternion CalculateRotation(this LeapTransform trs)
{
Vector3 up = trs.yBasis.ToVector3();
Vector3 forward = -trs.zBasis.ToVector3();
return(Quaternion.LookRotation(forward, up));
}
void Update()
{
if (!EditorApplication.isPlaying && SupportsEditorPersistence())
{
Transform editorPoseSpace;
LeapServiceProvider leapServiceProvider = FindObjectOfType <LeapServiceProvider>();
LeapTransform poseTransform = LeapTransform.Identity;
if (leapServiceProvider != null)
{
editorPoseSpace = leapServiceProvider.transform;
poseTransform = TestHandFactory.GetTestPoseLeftHandTransform(leapServiceProvider.editTimePose);
}
else
{
editorPoseSpace = transform;
}
Hand hand = TestHandFactory.MakeTestHand(Handedness == Chirality.Left, poseTransform).TransformedCopy(UnityMatrixExtension.GetLeapMatrix(editorPoseSpace));
//Hand hand = TestHandFactory.MakeTestHand(0, 0, Handedness == Chirality.Left).TransformedCopy(UnityMatrixExtension.GetLeapMatrix(editorPoseSpace));
if (GetLeapHand() == null)
{
SetLeapHand(hand);
InitHand();
BeginHand();
UpdateHand();
}
else
{
SetLeapHand(hand);
UpdateHand();
}
}
}
protected void updateIfTransformMoved(Frame source, ref Frame toUpdate)
{
if (transform.hasChanged)
{
_transformedFixedFrame = null;
_transformedUpdateFrame = null;
transform.hasChanged = false;
}
if (toUpdate == null)
{
LeapTransform leapTransform;
if (_temporalWarping != null)
{
Vector3 warpedPosition;
Quaternion warpedRotation;
_temporalWarping.TryGetWarpedTransform(LeapVRTemporalWarping.WarpedAnchor.CENTER, out warpedPosition, out warpedRotation, source.Timestamp);
warpedRotation = warpedRotation * transform.localRotation;
leapTransform = new LeapTransform(warpedPosition.ToVector(), warpedRotation.ToLeapQuaternion(), transform.lossyScale.ToVector() * 1e-3f);
leapTransform.MirrorZ();
}
else
{
leapTransform = transform.GetLeapMatrix();
}
toUpdate = source.TransformedCopy(leapTransform);
}
}
protected override Frame createFrame()
{
_originalFrame = TestHandFactory.MakeTestFrame(0, true, true);
LeapTransform forwardTransform = new LeapTransform(translation, LeapQuaternion.Identity);
return(_originalFrame.TransformedCopy(forwardTransform));
}
public void transformFrame(Frame source, Frame dest)
{
LeapTransform leapTransform;
_temporalWarping = null;
//////////////////////////////////////////////
// 细细研究这个问题 弄清楚是为什么
/////////////////////////////////////////////
if (_temporalWarping != null)
{
Vector3 warpedPosition;
Quaternion warpedRotation;
_temporalWarping.TryGetWarpedTransform(LeapVRTemporalWarping.WarpedAnchor.CENTER, out warpedPosition, out warpedRotation, source.Timestamp);
warpedRotation = warpedRotation * transform.localRotation;
leapTransform = new LeapTransform(warpedPosition.ToVector(), warpedRotation.ToLeapQuaternion(), transform.lossyScale.ToVector() * 1e-3f);
leapTransform.MirrorZ();
}
else
{
leapTransform = transform.GetLeapMatrix();
}
dest.CopyFrom(source).Transform(leapTransform);
}
protected void transformHands(ref LeapTransform LeftHand, ref LeapTransform RightHand)
{
LeapTransform leapTransform = transform.GetLeapMatrix();
LeftHand = new LeapTransform(leapTransform.TransformPoint(LeftHand.translation), leapTransform.TransformQuaternion(LeftHand.rotation));
RightHand = new LeapTransform(leapTransform.TransformPoint(RightHand.translation), leapTransform.TransformQuaternion(RightHand.rotation));
}
/**
* Extracts a transform matrix containing translation, rotation, and scale from a Unity Transform object and
* returns a Leap Motion LeapTransform object.
* Use this matrix to transform Leap Motion tracking data to the Unity world relative to the
* specified transform.
*
* In addition to applying the translation, rotation, and scale from the Transform object, the returned
* transformation changes the coordinate system from right- to left-handed and converts units from millimeters to meters
* by scaling.
* @returns A Leap.LeapTransform object representing the specified transform from Leap Motion into Unity space.
*/
public static LeapTransform GetLeapMatrix(this Transform t)
{
Vector scale = new Vector(t.lossyScale.x * MM_TO_M, t.lossyScale.y * MM_TO_M, t.lossyScale.z * MM_TO_M);
LeapTransform transform = new LeapTransform(t.position.ToVector(), t.rotation.ToLeapQuaternion(), scale);
transform.MirrorZ(); // Unity is left handed.
return(transform);
}
public static LeapTransform GetLeapTransform(Vector3 position, Quaternion rotation)
{
Vector scale = new Vector(MM_TO_M, MM_TO_M, MM_TO_M); // Leap units -> Unity units.
LeapTransform transform = new LeapTransform(position.ToVector(), rotation.ToLeapQuaternion(), scale);
transform.MirrorZ(); // Unity is left handed.
return(transform);
}
public void DrawBasis(Vector position, LeapTransform basis, float scale)
{
Vector3 origin = position.ToVector3();
Debug.DrawLine(origin, origin + basis.xBasis.ToVector3() * scale, Color.red);
Debug.DrawLine(origin, origin + basis.yBasis.ToVector3() * scale, Color.green);
Debug.DrawLine(origin, origin + basis.zBasis.ToVector3() * scale, Color.blue);
}
public void DrawBasis(RuntimeGizmoDrawer gizmoDrawer, Vector3 origin, LeapTransform basis, float scale) {
gizmoDrawer.color = Color.red;
gizmoDrawer.DrawLine(origin, origin + basis.xBasis.ToVector3() * scale);
gizmoDrawer.color = Color.green;
gizmoDrawer.DrawLine(origin, origin + basis.yBasis.ToVector3() * scale);
gizmoDrawer.color = Color.blue;
gizmoDrawer.DrawLine(origin, origin + basis.zBasis.ToVector3() * scale);
}
public void GetInterpolatedLeftRightTransform(Int64 time,
Int64 sourceTime,
Int64 leftId,
Int64 rightId,
out LeapTransform leftTransform,
out LeapTransform rightTransform)
{
leftTransform = LeapTransform.Identity;
rightTransform = LeapTransform.Identity;
UInt64 size = GetInterpolatedFrameSize(time);
IntPtr trackingBuffer = Marshal.AllocHGlobal((Int32)size);
eLeapRS result = LeapC.InterpolateFrameFromTime(_leapConnection, time, sourceTime, trackingBuffer, size);
reportAbnormalResults("LeapC get interpolated frame from time call was ", result);
if (result == eLeapRS.eLeapRS_Success)
{
LEAP_TRACKING_EVENT tracking_evt;
StructMarshal <LEAP_TRACKING_EVENT> .PtrToStruct(trackingBuffer, out tracking_evt);
int id;
LEAP_VECTOR position;
LEAP_QUATERNION orientation;
long handPtr = tracking_evt.pHands.ToInt64();
long idPtr = handPtr + _handIdOffset;
long posPtr = handPtr + _handPositionOffset;
long rotPtr = handPtr + _handOrientationOffset;
int stride = StructMarshal <LEAP_HAND> .Size;
for (uint i = tracking_evt.nHands; i-- != 0; idPtr += stride, posPtr += stride, rotPtr += stride)
{
id = Marshal.ReadInt32(new IntPtr(idPtr));
StructMarshal <LEAP_VECTOR> .PtrToStruct(new IntPtr(posPtr), out position);
StructMarshal <LEAP_QUATERNION> .PtrToStruct(new IntPtr(rotPtr), out orientation);
LeapTransform transform = new LeapTransform(position.ToLeapVector(), orientation.ToLeapQuaternion());
if (id == leftId)
{
leftTransform = transform;
}
else if (id == rightId)
{
rightTransform = transform;
}
}
}
Marshal.FreeHGlobal(trackingBuffer);
}
// These versions of GetPalmRotation & CalculateRotation return the opposite
// vector compared to LeapUnityExtension.CalculateRotation.
// This will be deprecated once LeapUnityExtension.CalculateRotation is
// flipped in the next release of LeapMotion Core Assets.
private Quaternion getRiggedPalmRotation()
{
if (hand_ != null)
{
LeapTransform trs = hand_.Basis;
return(calculateRotation(trs));
}
if (palm)
{
return(palm.rotation);
}
return(Quaternion.identity);
}
protected void transformHands(ref LeapTransform LeftHand, ref LeapTransform RightHand)
{
LeapTransform leapTransform;
/*if (_temporalWarping != null) {
* leapTransform = new LeapTransform(warpedPosition.ToVector(), warpedRotation.ToLeapQuaternion(), transform.lossyScale.ToVector() * 1e-3f);
* leapTransform.MirrorZ();
* } else*/{
leapTransform = transform.GetLeapMatrix();
}
LeftHand = new LeapTransform(leapTransform.TransformPoint(LeftHand.translation), leapTransform.TransformQuaternion(LeftHand.rotation));
RightHand = new LeapTransform(leapTransform.TransformPoint(RightHand.translation), leapTransform.TransformQuaternion(RightHand.rotation));
}
protected void updateIfTransformMoved(Frame source, ref Frame toUpdate)
{
if (transform.hasChanged)
{
_transformedFixedFrame = null;
_transformedUpdateFrame = null;
transform.hasChanged = false;
//Debug.Log("has changed ");
}
if (toUpdate == null)
{
LeapTransform leapTransform;
if (_temporalWarping != null)
{
Vector3 warpedPosition;
Quaternion warpedRotation;
_temporalWarping.TryGetWarpedTransform(LeapVRTemporalWarping.WarpedAnchor.CENTER, out warpedPosition, out warpedRotation, source.Timestamp);
warpedRotation = warpedRotation * transform.localRotation;
leapTransform = new LeapTransform(warpedPosition.ToVector(), warpedRotation.ToLeapQuaternion(), transform.lossyScale.ToVector() * 1e-3f);
leapTransform.MirrorZ();
}
else
{
leapTransform = transform.GetLeapMatrix();
//Debug.Log("This is the transforme" + leapTransform.translation);
}
// Debug.Log("This is the source" + source);
//toUpdate = source.TransformedCopy(leapTransform);
try
{
toUpdate = source.TransformedCopy(leapTransform);
//Debug.Log(webController.Frame());
//toUpdate = source.TransformedCopy(leapTransform);
}
catch (Exception e)
{
//Debug.Log("leaptransform " + transform);
Debug.Log("Type: " + e + "Message: " + e.Message + " stacktrace:" + e.StackTrace);
}
//toUpdate = webController.Frame().TransformedCopy(leapTransform);
}
}
public void GetInterpolatedLeftRightTransform(long time, long sourceTime, long leftId, long rightId, out LeapTransform leftTransform, out LeapTransform rightTransform)
{
leftTransform = LeapTransform.Identity;
rightTransform = LeapTransform.Identity;
ulong interpolatedFrameSize = this.GetInterpolatedFrameSize(time);
IntPtr pEvent = Marshal.AllocHGlobal((int)interpolatedFrameSize);
eLeapRS result = LeapC.InterpolateFrameFromTime(this._leapConnection, time, sourceTime, pEvent, interpolatedFrameSize);
this.reportAbnormalResults("LeapC get interpolated frame from time call was ", result);
if (result == eLeapRS.eLeapRS_Success)
{
LEAP_TRACKING_EVENT leap_tracking_event;
StructMarshal <LEAP_TRACKING_EVENT> .PtrToStruct(pEvent, out leap_tracking_event);
int num3 = leap_tracking_event.pHands.ToInt32();
int num4 = num3 + _handIdOffset;
int num5 = num3 + _handPositionOffset;
int num6 = num3 + _handOrientationOffset;
int size = StructMarshal <LEAP_HAND> .Size;
uint nHands = leap_tracking_event.nHands;
while (nHands-- != 0)
{
LEAP_VECTOR leap_vector;
LEAP_QUATERNION leap_quaternion;
int num2 = Marshal.ReadInt32(new IntPtr(num4));
StructMarshal <LEAP_VECTOR> .PtrToStruct(new IntPtr(num5), out leap_vector);
StructMarshal <LEAP_QUATERNION> .PtrToStruct(new IntPtr(num6), out leap_quaternion);
LeapTransform transform = new LeapTransform(leap_vector.ToLeapVector(), leap_quaternion.ToLeapQuaternion());
if (num2 == leftId)
{
leftTransform = transform;
}
else if (num2 == rightId)
{
rightTransform = transform;
}
num4 += size;
num5 += size;
num6 += size;
}
}
Marshal.FreeHGlobal(pEvent);
}
public void Start()
{
_settings = LeapSettings.Get(DataDir);
_xform = new LeapTransform(Vector.Zero, LeapQuaternion.Identity, new Vector(MillimetersToMeters, MillimetersToMeters, MillimetersToMeters));
_xform.MirrorZ();
_controller = new Controller();
_controller.Connect += HandleLeapConnected;
_controller.Disconnect += HandleLeapDisconnected;
_controller.StartConnection();
var tickRate = _settings.UpdateRate_ms;
if (tickRate <= 0)
{
tickRate = LeapSettings.Defaults().UpdateRate_ms;
}
_timer = new Timer(HandleTimerTick, null, 0, tickRate);
}
IEnumerator UpdateTrackingAfterLeapInit()
{
while (((LeapServiceProvider)Hands.Provider).GetLeapController() == null)
{
yield return(null);
}
// To simplify the configuration values, positive X angles tilt the Leap towards the screen no matter how its mounted.
// Therefore, we must convert to the real values before using them.
// If top mounted, the X rotation should be negative if tilted towards the screen so we must negate the X rotation in this instance.
var isTopMounted = Mathf.Approximately(PhysicalConfigurable.Config.LeapRotationD.z, 180f);
float xAngleDegree = isTopMounted ? -PhysicalConfigurable.Config.LeapRotationD.x : PhysicalConfigurable.Config.LeapRotationD.x;
SetLeapTrackingMode();
TrackingTransform = new LeapTransform(
PhysicalConfigurable.Config.LeapPositionRelativeToScreenBottomM.ToVector(),
Quaternion.Euler(xAngleDegree, PhysicalConfigurable.Config.LeapRotationD.y, PhysicalConfigurable.Config.LeapRotationD.z).ToLeapQuaternion()
);
}
protected override void transformFrame(Frame source, Frame dest)
{
LeapTransform leapTransform = LeapTransform.Identity;
if (mainCamera != null)
{
//By default, use the camera transform matrix to transform the frame into
leapTransform = mainCamera.transform.GetLeapMatrix();
leapTransform.scale = Vector.Ones * 1e-3f;
//If the application is playing then we can try to use temporal warping
if (Application.isPlaying)
{
leapTransform = GetWarpedMatrix(source.Timestamp);
}
}
dest.CopyFrom(source).Transform(leapTransform);
}
private void GenerateFrame()
{
hands.Clear();
LeapTransform leapTransform = new LeapTransform(Vector.Zero, LeapQuaternion.Identity, Vector.Ones);
if (rightControllerHand != null && rightControllerHand.IsActive)
{
hands.Add(rightControllerHand.LeapHand.Transform(leapTransform));
}
if (leftControllerHand != null && leftControllerHand.IsActive)
{
hands.Add(leftControllerHand.LeapHand.Transform(leapTransform));
}
currentFrame.Id = frameID;
currentFrame.Timestamp = timeStamp;
frameID++;
timeStamp++;
}
protected Frame getTransformedFrame(Frame source)
{
LeapTransform leapTransform;
if (_temporalWarping != null)
{
Vector3 warpedPosition;
Quaternion warpedRotation;
_temporalWarping.TryGetWarpedTransform(LeapVRTemporalWarping.WarpedAnchor.CENTER, out warpedPosition, out warpedRotation, source.Timestamp);
warpedRotation = warpedRotation * transform.localRotation;
leapTransform = new LeapTransform(warpedPosition.ToVector(), warpedRotation.ToLeapQuaternion(), transform.lossyScale.ToVector() * 1e-3f);
leapTransform.MirrorZ();
}
else
{
leapTransform = transform.GetLeapMatrix();
}
return(source.TransformedCopy(leapTransform));
}
public void PositionCamera()
{
Transform referenceObject = transform;
if (referenceObject == null)
{
HandController tmp = GameObject.FindObjectOfType <HandController>();
if (tmp)
{
referenceObject = tmp.transform;
}
}
if (referenceObject == null)
{
GameObject tmp = GameObject.Find("Main Camera");
if (tmp)
{
referenceObject = tmp.transform;
}
}
if (referenceObject == null)
{
return;
}
LeapTransform referenceTransform = new LeapTransform(referenceObject.position, referenceObject.rotation);
referenceTransform.Position = referenceObject.position;
referenceTransform.Rotation = referenceObject.rotation;
Vector3 offsetCameraToLeap = OffsetCameraToLeap * 1.0f / clientUnitLengthInMillimeters;
offsetCameraToLeap = referenceObject.rotation * offsetCameraToLeap;
referenceTransform.Position = referenceObject.position + offsetCameraToLeap;
Scene.LeapOriginInClient = referenceTransform;
}
/**
* Extracts a transform matrix containing translation, rotation, and scale from a Unity Transform object and
* returns a Leap Motion LeapTransform object.
* Use this matrix to transform Leap Motion tracking data to the Unity world relative to the
* specified transform.
*
* In addition to applying the translation, rotation, and scale from the Transform object, the returned
* transformation changes the coordinate system from right- to left-handed and converts units from millimeters to meters
* by scaling.
* @returns A Leap.LeapTransform object representing the specified transform from Leap Motion into Unity space.
*/
public static LeapTransform GetLeapMatrix(this Transform t) {
Vector scale = new Vector(t.lossyScale.x * MM_TO_M, t.lossyScale.y * MM_TO_M, t.lossyScale.z * MM_TO_M);
LeapTransform transform = new LeapTransform(t.position.ToVector(), t.rotation.ToLeapQuaternion(), scale);
transform.MirrorZ(); // Unity is left handed.
return transform;
}
protected override Frame createFrame() {
_originalFrame = TestHandFactory.MakeTestFrame(0, true, true);
LeapTransform forwardTransform = new LeapTransform(translation, LeapQuaternion.Identity);
return _originalFrame.TransformedCopy(forwardTransform);
}
protected void transformFrame(Frame source, Frame dest) {
LeapTransform leapTransform;
if (_temporalWarping != null) {
Vector3 warpedPosition;
Quaternion warpedRotation;
_temporalWarping.TryGetWarpedTransform(LeapVRTemporalWarping.WarpedAnchor.CENTER, out warpedPosition, out warpedRotation, source.Timestamp);
warpedRotation = warpedRotation * transform.localRotation;
leapTransform = new LeapTransform(warpedPosition.ToVector(), warpedRotation.ToLeapQuaternion(), transform.lossyScale.ToVector() * 1e-3f);
leapTransform.MirrorZ();
} else {
leapTransform = transform.GetLeapMatrix();
}
dest.CopyFrom(source).Transform(leapTransform);
}
protected void OnPreCullHandTransforms(Camera camera)
{
if (updateHandInPrecull)
{
//Don't update pre cull for preview, reflection, or scene view cameras
if (camera == null)
{
camera = preCullCamera;
}
switch (camera.cameraType)
{
case CameraType.Preview:
#if UNITY_2017_1_OR_NEWER
case CameraType.Reflection:
#endif
case CameraType.SceneView:
return;
}
if (Application.isPlaying &&
!manualUpdateHasBeenCalledSinceUpdate &&
_leapController != null)
{
manualUpdateHasBeenCalledSinceUpdate = true;
//Find the left and/or right hand(s) to latch
Hand leftHand = null, rightHand = null;
LeapTransform precullLeftHand = LeapTransform.Identity;
LeapTransform precullRightHand = LeapTransform.Identity;
for (int i = 0; i < CurrentFrame.Hands.Count; i++)
{
Hand updateHand = CurrentFrame.Hands[i];
if (updateHand.IsLeft && leftHand == null)
{
leftHand = updateHand;
}
else if (updateHand.IsRight && rightHand == null)
{
rightHand = updateHand;
}
}
//Determine their new Transforms
var interpolationTime = CalculateInterpolationTime();
_leapController.GetInterpolatedLeftRightTransform(
interpolationTime + (ExtrapolationAmount * 1000),
interpolationTime - (BounceAmount * 1000),
(leftHand != null ? leftHand.Id : 0),
(rightHand != null ? rightHand.Id : 0),
out precullLeftHand,
out precullRightHand);
bool leftValid = precullLeftHand.translation != Vector.Zero;
bool rightValid = precullRightHand.translation != Vector.Zero;
transformHands(ref precullLeftHand, ref precullRightHand);
//Calculate the delta Transforms
if (rightHand != null && rightValid)
{
_transformArray[0] =
Matrix4x4.TRS(precullRightHand.translation.ToVector3(),
precullRightHand.rotation.ToQuaternion(),
Vector3.one)
* Matrix4x4.Inverse(Matrix4x4.TRS(rightHand.PalmPosition.ToVector3(),
rightHand.Rotation.ToQuaternion(),
Vector3.one));
}
if (leftHand != null && leftValid)
{
_transformArray[1] =
Matrix4x4.TRS(precullLeftHand.translation.ToVector3(),
precullLeftHand.rotation.ToQuaternion(),
Vector3.one)
* Matrix4x4.Inverse(Matrix4x4.TRS(leftHand.PalmPosition.ToVector3(),
leftHand.Rotation.ToQuaternion(),
Vector3.one));
}
//Apply inside of the vertex shader
Shader.SetGlobalMatrixArray(HAND_ARRAY_GLOBAL_NAME, _transformArray);
}
}
}
protected virtual LeapTransform GetWarpedMatrix(long timestamp,
bool updateTemporalCompensation = true)
{
LeapTransform leapTransform;
//Calculate a Temporally Warped Pose
if (Application.isPlaying &&
updateTemporalCompensation &&
transformHistory.history.IsFull &&
_temporalWarpingMode != TemporalWarpingMode.Off)
{
transformHistory.SampleTransform(timestamp
- (long)(warpingAdjustment * 1000f)
- (_temporalWarpingMode ==
TemporalWarpingMode.Images ? -20000 : 0),
out warpedPosition, out warpedRotation);
}
// Normalize the rotation Quaternion.
warpedRotation = Quaternion.Lerp(warpedRotation, Quaternion.identity, 0f);
//Calculate the Current Pose
Pose currentPose = Pose.identity;
if (_deviceOffsetMode == DeviceOffsetMode.Transform && deviceOrigin != null &&
(!Application.isPlaying || _temporalWarpingMode == TemporalWarpingMode.Off))
{
// Transform mode at edit-time -- just use the transform pose.
currentPose = deviceOrigin.ToPose();
}
else if (!Application.isPlaying)
{
currentPose.position =
currentPose.rotation * Vector3.up * deviceOffsetYAxis
+ currentPose.rotation * Vector3.forward * deviceOffsetZAxis;
currentPose.rotation = Quaternion.Euler(deviceTiltXAxis, 0f, 0f);
currentPose = transform.ToLocalPose().Then(currentPose);
}
else
{
transformHistory.SampleTransform(timestamp, out currentPose.position,
out currentPose.rotation);
}
// Choose between Warped and Current Pose
bool useCurrentPosition =
_temporalWarpingMode == TemporalWarpingMode.Off ||
!Application.isPlaying;
warpedPosition = useCurrentPosition ? currentPose.position : warpedPosition;
warpedRotation = useCurrentPosition ? currentPose.rotation : warpedRotation;
// Apply offsets (when applicable)
if (Application.isPlaying)
{
if (_deviceOffsetMode != DeviceOffsetMode.Transform)
{
warpedPosition += warpedRotation * Vector3.up * deviceOffsetYAxis
+ warpedRotation * Vector3.forward * deviceOffsetZAxis;
warpedRotation *= Quaternion.Euler(deviceTiltXAxis, 0f, 0f);
warpedRotation *= Quaternion.Euler(-90f, 180f, 0f);
}
else
{
warpedRotation *= Quaternion.Euler(-90f, 90f, 90f);
}
}
if (this == null)
{
// We are being destroyed, get outta here.
return(LeapTransform.Identity);
}
if (transform.parent != null &&
_deviceOffsetMode != DeviceOffsetMode.Transform)
{
leapTransform = new LeapTransform(
transform.parent.TransformPoint(warpedPosition).ToVector(),
(transform.parent.rotation * warpedRotation).ToLeapQuaternion(),
transform.lossyScale.ToVector() * 1e-3f
);
}
else
{
leapTransform = new LeapTransform(
warpedPosition.ToVector(),
warpedRotation.ToLeapQuaternion(),
transform.lossyScale.ToVector() * 1e-3f
);
}
leapTransform.MirrorZ();
return(leapTransform);
}
protected override void transformFrame(Frame source, Frame dest)
{
LeapTransform leapTransform = GetWarpedMatrix(source.Timestamp);
dest.CopyFrom(source).Transform(leapTransform);
}
public void LateUpdateHandTransforms(Camera camera)
{
if (_updateHandInPrecull)
{
#if UNITY_EDITOR
//Hard-coded name of the camera used to generate the pre-render view
if (camera.gameObject.name == "PreRenderCamera")
{
return;
}
bool isScenePreviewCamera = camera.gameObject.hideFlags == HideFlags.HideAndDontSave;
if (isScenePreviewCamera)
{
return;
}
#endif
if (Application.isPlaying && !manualUpdateHasBeenCalledSinceUpdate && leap_controller_ != null)
{
manualUpdateHasBeenCalledSinceUpdate = true;
//Find the Left and/or Right Hand(s) to Latch
Hand leftHand = null, rightHand = null;
LeapTransform PrecullLeftHand = LeapTransform.Identity, PrecullRightHand = LeapTransform.Identity;
for (int i = 0; i < CurrentFrame.Hands.Count; i++)
{
Hand updateHand = CurrentFrame.Hands[i];
if (updateHand.IsLeft && leftHand == null)
{
leftHand = updateHand;
}
else if (updateHand.IsRight && rightHand == null)
{
rightHand = updateHand;
}
}
//Determine their new Transforms
leap_controller_.GetInterpolatedLeftRightTransform(CalculateInterpolationTime() + (ExtrapolationAmount * 1000), CalculateInterpolationTime() - (BounceAmount * 1000), (leftHand != null ? leftHand.Id : 0), (rightHand != null ? rightHand.Id : 0), out PrecullLeftHand, out PrecullRightHand);
bool LeftValid = PrecullLeftHand.translation != Vector.Zero; bool RightValid = PrecullRightHand.translation != Vector.Zero;
transformHands(ref PrecullLeftHand, ref PrecullRightHand);
//Calculate the Delta Transforms
if (rightHand != null && RightValid)
{
_transformArray[0] =
Matrix4x4.TRS(PrecullRightHand.translation.ToVector3(), PrecullRightHand.rotation.ToQuaternion(), Vector3.one) *
Matrix4x4.Inverse(Matrix4x4.TRS(rightHand.PalmPosition.ToVector3(), rightHand.Rotation.ToQuaternion(), Vector3.one));
}
if (leftHand != null && LeftValid)
{
_transformArray[1] =
Matrix4x4.TRS(PrecullLeftHand.translation.ToVector3(), PrecullLeftHand.rotation.ToQuaternion(), Vector3.one) *
Matrix4x4.Inverse(Matrix4x4.TRS(leftHand.PalmPosition.ToVector3(), leftHand.Rotation.ToQuaternion(), Vector3.one));
}
//Apply inside of the vertex shader
Shader.SetGlobalMatrixArray(HAND_ARRAY, _transformArray);
}
}
}
public override void OnInit(Controller arg0)
{
base.OnInit(arg0);
LeapTransform = new LeapTransform(SensorOrientation.DesktopLeftward);
//LeapTransform = new LeapTransform(SensorOrientation.MonitorSkyward);
}
// Update is called once per frame
void Update()
{
//Frame frame = controller.Frame(); // controller is a Controller object
//if (frame.Hands.Count > 0)
//{
//List<Hand> hands = frame.Hands;
//Hand firstHand = hands[0];
//print(firstHand.Fingers[1].TipPosition.ToVector3());
//if (initHand == false)
//{
// hand_model = GetComponent("HandModels") as HandModel;
// print(hand_model);
// //right_leap_hand = hand_model.GetLeapHand();
// //if (right_leap_hand == null) Debug.LogError("No right_leap_hand founded");
// //initHand = true;
//}
//if (initHand == true)
//{
// for (int i = 0; i < HandModel.NUM_FINGERS; i++)
// {
// FingerModel finger = hand_model.fingers[i];
// // draw ray from finger tips (enable Gizmos in Game window to see)
// Debug.DrawRay(finger.GetTipPosition(), finger.GetRay().direction, Color.red);
// }
//}
//}
//LeapRightHand.localRotation = Quaternion.Euler(new Vector3(0, 0, 0));
//readObject();
Frame frame = controller.Frame(); // controller is a Controller object
if (frame.Hands.Count > 0)
{
//if (initHand == true)
//{
//print(frame.Hands.Count);
List <Hand> hands = frame.Hands;
right_leap_hand = hands[0];
if (right_leap_hand.IsRight)
{
//Leap.Unity.Pose pose = new Leap.Unity.Pose(right_leap_hand.PalmPosition.ToVector3(), right_leap_hand.Rotation.ToQuaternion());
LeapTransform leapMatrix = transform.GetLeapMatrix();
//palmPossition[0] = right_leap_hand.PalmPosition.ToVector3();
//palmPossition[1] = pose.position;
//Vector3 handPosition = pose.position;
//print(palmPossition[0]);
//float handYBasis = right_leap_hand.PalmNormal.Roll;
//float pitch = right_leap_hand.Direction.Pitch;
//float yaw = right_leap_hand.Direction.Yaw;
//float x = right_leap_hand.PalmNormal.Pitch;
//float roll = right_leap_hand.PalmNormal.Roll;
////Vector normalPalm = new Vector(pitch, yaw, roll);
//LeapQuaternion handRotation = right_leap_hand.Basis.rotation;
//handRotation.z = roll;
//handRotation.y = yaw;
//handRotation.x = pitch;
//Vector handZBasis = -right_leap_hand.Direction;
Vector handOrigin = right_leap_hand.PalmPosition;
Vector normalPalm = right_leap_hand.PalmNormal;
//print(normalPalm);
// print(handOrigin.Normalized);
//print(xBasis);
//print(Matrix4x4.TRS(handOrigin,
// Quaternion.identity,
// new Vector3(transform.lossyScale.x, transform.lossyScale.x, transform.lossyScale.z)));
//print(rayStart.transform.worldToLocalMatrix);
//Matrix handTransform = new Matrix(handXBasis, handYBasis, handZBasis, handOrigin);
//handTransform = handTransform.RigidInverse();
//Vector transformedPosition = handTransform.TransformPoint(right_leap_hand.PalmPosition);
//float locationPart = normalPalm.x
Vector3 normalPalmUnity = leapMatrix.TransformDirection(normalPalm).ToVector3();
Vector3 leapHandPosition = leapMatrix.TransformPoint(handOrigin).ToVector3();
//Quaternion leapHandDirection = leapMatrix.translation
//Quaternion leapHandDirection = handRotation.ToQuaternion();
leapHandPosition.y -= 1.8f;
leapHandPosition.x -= 0.7f;
LeapRightHandRay.position = leapHandPosition;
//print(leapHandDirection);
//Vector3 rotationToHand = new Vector3(leapHandDirection.eulerAngles.x, leapHandDirection.eulerAngles.y, leapHandDirection.eulerAngles.z);
rayStart = Instantiate(emptyObj, LeapRightHandRay.position, Quaternion.identity, LeapRightHandRay);
//print(leapHandDirection.eulerAngles);
LeapRightHandRay.forward = normalPalmUnity;
//LeapRightHandRay.localRotation = Quaternion.Euler(rotationToHand);
//LeapRightHandRay.localRotation = Quaternion.FromToRotation(LeapRightHandRay.forward, normalPalmUnity);
//print(LeapRightHandRay.forward);
//float step = speed / 4 * Time.deltaTime;
//readObject();
//print(printMessage.isActivated);
//cubeRubick.transform.position = Vector3.MoveTowards(cubeRubick.transform.position, LeapRightHandRay.position, step);
//Finger leapFinger = firstHand.Fingers[1];
//Vector transformedPosition = handTransform.TransformPoint(leapFinger.TipPosition);
//Vector transformedDirection = handTransform.TransformDirection(leapFinger.Direction);
//print(transformedPosition);
// Do something with the transformed fingers
//Leap.Vector palmPosition = firstHand.PalmPosition;
//Leap.Vector palmDirection = firstHand.PalmNormal;
//Vector3 vectpalmPosition = new Vector3(palmPosition.x,
// palmPosition.y,
// palmPosition.z);
//print(vectpalmPosition);
////print("Trasform ray:");
////print(LeapRightHand.position);
////print("Trasform hand pos:");
////print(vectpalmPosition);
//initHand = false;
//GameObject rayStart = Instantiate(emptyObj, vectpalmPosition, Quaternion.identity, parentHand);
////Vector3 unityPosition = ToPositionVector3(palmDirection);
////LeapRightHand.localRotation = Quaternion.Euler(new Vector3(0, 0, 0));
//Vector3 ray = rayStart.transform.position;
//RaycastHit hit;
////print(ray);
////Intersecteaza raza vreun obiect in layerMask ?
//if (Physics.Raycast(ray, LeapRightHand.forward, out hit, Mathf.Infinity, layerMask))
//{
// Debug.DrawRay(ray, LeapRightHand.forward * hit.distance, Color.yellow);
// print(hit.collider.gameObject);
// //print(hit.collider.gameObject.name);
//}
//else
//{
// Debug.DrawRay(ray, LeapRightHand.forward * 1000, Color.green);
//}
//print(firstHand.PalmNormal);
// }
//}
//}
}
}
}
public Frame GetTransformedFrame(LeapTransform trs, int history = 0)
{
return(processor.frame.TransformedCopy(trs));
}
