public virtual void OnColliderEventDragStart(ColliderButtonEventData eventData)
{
if (eventData.button != m_grabButton)
{
return;
}
var casterPose = GetEventPose(eventData);
var offsetPose = RigidPose.FromToPose(casterPose, new RigidPose(transform));
if (alignPosition)
{
offsetPose.pos = Vector3.zero;
}
if (alignRotation)
{
offsetPose.rot = Quaternion.identity;
}
if (eventData != grabbedEvent && beforeRelease != null)
{
beforeRelease.Invoke(this);
}
eventList.AddUniqueKey(eventData, offsetPose);
if (afterGrabbed != null)
{
afterGrabbed.Invoke(this);
}
}
public virtual void OnColliderEventDragFixedUpdate(ColliderButtonEventData eventData)
{
if (eventData != grabbedEvent)
{
return;
}
if (moveByVelocity)
{
// if rigidbody exists, follow eventData caster using physics
var casterPose = GetEventPose(eventData);
var offsetPose = eventList.GetLastValue();
if (alignPosition)
{
offsetPose.pos = alignPositionOffset;
}
if (alignRotation)
{
offsetPose.rot = Quaternion.Euler(alignRotationOffset);
}
var targetPose = casterPose * offsetPose;
RigidPose.SetRigidbodyVelocity(rigid, rigid.position, targetPose.pos, followingDuration);
RigidPose.SetRigidbodyAngularVelocity(rigid, rigid.rotation, targetPose.rot, followingDuration, overrideMaxAngularVelocity);
}
}
public static void Test()
{
var pool = new BufferPool();
var registry = new CollisionTaskRegistry();
registry.Register(new SpherePairCollisionTask());
registry.Register(new SphereCapsuleCollisionTask());
registry.Register(new SphereBoxCollisionTask());
registry.Register(new CapsulePairCollisionTask());
registry.Register(new CapsuleBoxCollisionTask());
registry.Register(new BoxPairCollisionTask());
var sphere = new Sphere(1);
var capsule = new Capsule(0.5f, 1f);
var box = new Box(1f, 1f, 1f);
var poseA = new RigidPose {
Position = new Vector3(0, 0, 0), Orientation = BepuUtilities.Quaternion.Identity
};
var poseB = new RigidPose {
Position = new Vector3(0, 1, 0), Orientation = BepuUtilities.Quaternion.Identity
};
Test(ref sphere, ref sphere, ref poseA, ref poseB, pool, registry, 1 << 25);
Test(ref sphere, ref capsule, ref poseA, ref poseB, pool, registry, 1 << 25);
Test(ref sphere, ref box, ref poseA, ref poseB, pool, registry, 1 << 25);
Test(ref capsule, ref capsule, ref poseA, ref poseB, pool, registry, 1 << 25);
Test(ref capsule, ref box, ref poseA, ref poseB, pool, registry, 1 << 25);
Test(ref box, ref box, ref poseA, ref poseB, pool, registry, 1 << 25);
Console.ReadKey();
}
protected override Grabber CreateGrabber(PointerEventData eventData)
{
var hitResult = eventData.pointerPressRaycast;
float distance;
switch (eventData.button)
{
case PointerEventData.InputButton.Middle:
case PointerEventData.InputButton.Right:
distance = Mathf.Min(hitResult.distance, initGrabDistance);
break;
case PointerEventData.InputButton.Left:
distance = hitResult.distance;
break;
default:
return(null);
}
var grabber = Grabber.Get(eventData);
grabber.grabber2hit = new RigidPose(new Vector3(0f, 0f, distance), Quaternion.identity);
grabber.hit2pivot = RigidPose.FromToPose(new RigidPose(hitResult.worldPosition, hitResult.module.eventCamera.transform.rotation), new RigidPose(transform));
return(grabber);
}
public virtual void OnColliderEventPressDown(ColliderButtonEventData eventData)
{
if (eventData.button != m_grabButton || eventList.ContainsKey(eventData) || eventData == m_bannedEventData)
{
return;
}
var casterPose = GetEventPose(eventData);
var offsetPose = RigidPose.FromToPose(casterPose, new RigidPose(transform));
if (alignPosition)
{
offsetPose.pos = Vector3.zero;
}
if (alignRotation)
{
offsetPose.rot = Quaternion.identity;
}
if (!m_multipleGrabbers && eventList.Count > 0)
{
Release();
}
eventList.AddUniqueKey(eventData, offsetPose);
if (afterGrabbed != null)
{
afterGrabbed.Invoke(this);
}
}
public bool CalculateModelSpaceAndLength()
{
// findout model front/up axis
var wrist = m_modelJoints[HandJointName.Wrist];
var furthest = FindFurthestFingerTip();
var thinnest = FindMostThinnestFingerTip();
var thickest = FindMostThickestFingerTip();
if (wrist == null || furthest == null || thinnest == null || thickest == null || thinnest == thickest)
{
Debug.LogError(logPrefix + "Unable to fine model space because no valid finger found. furthest:" + (furthest ? furthest.name : "null") + " furthest:" + (thinnest ? thinnest.name : "null") + " furthest:" + (thickest ? thickest.name : "null"));
m_isValidModel = false;
return(false);
}
// find forward
var forward = NormalizeAxis(wrist.InverseTransformPoint(furthest.position));
var vThinnest = wrist.InverseTransformPoint(thinnest.position);
var vThickest = wrist.InverseTransformPoint(thickest.position);
var up = NormalizeAxis(m_modelHanded == Handed.Right ? Vector3.Cross(vThickest, vThinnest) : Vector3.Cross(vThinnest, vThickest));
if (Vector3.Dot(forward, up) != 0f)
{
Debug.LogError(logPrefix + "Unable to find valid model forward/up. forward:" + forward + " up:" + up);
m_isValidModel = false;
return(false);
}
m_isValidModel = true;
m_modelOffset = new RigidPose(Vector3.zero, Quaternion.LookRotation(forward, up));
m_modelOffsetInverse = m_modelOffset.GetInverse();
m_modelLength = CalculateModelLength();
return(true);
}
void AddShape(Shapes shapes, TypedIndex shapeIndex, ref RigidPose pose, ref Vector3 color)
{
switch (shapeIndex.Type)
{
case Sphere.Id:
{
SphereInstance instance;
instance.Position = pose.Position;
instance.Radius = shapes.GetShape <Sphere>(shapeIndex.Index).Radius;
Helpers.PackOrientation(ref pose.Orientation, out instance.PackedOrientation);
instance.PackedColor = Helpers.PackColor(ref color);
spheres.Add(ref instance, new PassthroughArrayPool <SphereInstance>());
}
break;
case Capsule.Id:
{
CapsuleInstance instance;
instance.Position = pose.Position;
ref var capsule = ref shapes.GetShape <Capsule>(shapeIndex.Index);
instance.Radius = capsule.Radius;
instance.HalfLength = capsule.HalfLength;
instance.PackedOrientation = Helpers.PackOrientationU64(ref pose.Orientation);
instance.PackedColor = Helpers.PackColor(ref color);
capsules.Add(ref instance, new PassthroughArrayPool <CapsuleInstance>());
}
break;
public virtual void OnColliderEventDragUpdate(ColliderButtonEventData eventData)
{
if (eventData != grabbedEvent)
{
return;
}
if (!moveByVelocity)
{
// if rigidbody doesn't exist, just move to eventData caster's pose
var casterPose = GetEventPose(eventData);
var offsetPose = eventList.GetLastValue();
if (alignPosition)
{
offsetPose.pos = alignPositionOffset;
}
if (alignRotation)
{
offsetPose.rot = Quaternion.Euler(alignRotationOffset);
}
m_prevPose = new RigidPose(transform);
if (rigid != null)
{
rigid.velocity = Vector3.zero;
rigid.angularVelocity = Vector3.zero;
}
var targetPose = casterPose * offsetPose;
transform.position = targetPose.pos;
transform.rotation = targetPose.rot;
}
}
public static void SortDeviceIndicesByDirection(List <uint> deviceList, RigidPose sortingReference)
{
if (deviceList == null || deviceList.Count == 0)
{
return;
}
for (int i = 0, imax = deviceList.Count; i < imax; ++i)
{
var deviceIndex = deviceList[i];
if (!VRModule.IsValidDeviceIndex(deviceIndex))
{
continue;
}
var deviceState = VRModule.GetCurrentDeviceState(deviceIndex);
if (deviceState.isConnected)
{
var localPos = sortingReference.InverseTransformPoint(deviceState.pose.pos);
s_deviceDirPoint[deviceIndex] = GetDirectionPoint(new Vector2(localPos.x, localPos.z));
}
else
{
s_deviceDirPoint[deviceIndex] = -1f;
}
}
deviceList.Sort(CompareDirection);
}
public override void OnNewPoses()
{
var deviceIndex = viveRole.GetDeviceIndex();
// set targetPose to device pose
targetPose = VivePose.GetPose(deviceIndex) * new RigidPose(posOffset, Quaternion.Euler(rotOffset));
ModifyPose(ref targetPose, origin);
// transform to world space
var o = origin != null ? origin : transform.parent;
if (o != null)
{
targetPose = new RigidPose(o) * targetPose;
targetPose.pos.Scale(o.localScale);
}
if (m_snap)
{
m_snap = false;
transform.position = targetPose.pos;
transform.rotation = targetPose.rot;
}
SetIsValid(VivePose.IsValid(deviceIndex));
}
public virtual void OnColliderEventDragStart(ColliderButtonEventData eventData)
{
if (!IsValidGrabButton(eventData))
{
return;
}
if (!m_allowMultipleGrabbers)
{
ClearGrabbers(false);
ClearEventGrabberSet();
}
var grabber = BasicGrabbable.Grabber.Get(eventData);
var offset = RigidPose.FromToPose(grabber.grabberOrigin, new RigidPose(transform));
grabber.grabOffset = offset;
if (m_eventGrabberSet == null)
{
m_eventGrabberSet = new IndexedTable <ColliderButtonEventData, BasicGrabbable.Grabber>();
}
m_eventGrabberSet.Add(eventData, grabber);
AddGrabber(grabber);
Vector3 deltaVec = grabber.grabberOrigin.pos - transform.position;
Vector3 deltaVecProjected = Vector3.ProjectOnPlane(deltaVec, transform.up).normalized;
initialDeltaDegrees = Vector3.SignedAngle(transform.forward, deltaVecProjected, transform.up);
}
private void AssignHandJoint(RigidPose handPose, bool isLeft, JointEnumArray joints, HandJointName jointName, VRBoneTransform_t[] boneTransforms, int steamBoneIndex)
{
VRBoneTransform_t bone = boneTransforms[steamBoneIndex];
Vector3 position = new Vector3(-bone.position.v0, bone.position.v1, bone.position.v2);
Quaternion rotation = new Quaternion(bone.orientation.x, -bone.orientation.y, -bone.orientation.z, bone.orientation.w);
if (steamBoneIndex == SteamVR_Skeleton_JointIndexes.wrist)
{
if (isLeft)
{
rotation *= s_leftSkeletonWristFixRotation;
}
else
{
rotation *= s_rightSkeletonWristFixRotation;
}
}
else
{
if (isLeft)
{
rotation *= s_leftSkeletonFixRotation;
}
else
{
rotation *= s_rightSkeletonFixRotation;
}
}
joints[jointName] = new JointPose(handPose * new RigidPose(position, rotation));
}
public static void Test()
{
var pool = new BufferPool();
var registry = new CollisionTaskRegistry();
var task = new SpherePairCollisionTask();
registry.Register(task);
var continuations = new ContinuationsTest();
var filters = new SubtaskFiltersTest();
var sphere = new Sphere(1);
var poseA = new RigidPose {
Position = new Vector3(0, 0, 0), Orientation = BepuUtilities.Quaternion.Identity
};
var poseB = new RigidPose {
Position = new Vector3(0, 1, 0), Orientation = BepuUtilities.Quaternion.Identity
};
Action <int> action = iterationCount =>
{
var batcher = new StreamingBatcher(pool, registry);
for (int i = 0; i < iterationCount; ++i)
{
batcher.Add(ref sphere, ref sphere, ref poseA, ref poseB, new ContinuationIndex(), ref continuations, ref filters);
batcher.Add(ref sphere, ref sphere, ref poseA, ref poseB, new ContinuationIndex(), ref continuations, ref filters);
batcher.Add(ref sphere, ref sphere, ref poseA, ref poseB, new ContinuationIndex(), ref continuations, ref filters);
batcher.Add(ref sphere, ref sphere, ref poseA, ref poseB, new ContinuationIndex(), ref continuations, ref filters);
}
batcher.Flush(ref continuations, ref filters);
};
var time0 = Test(action, 1 << 25);
Console.WriteLine($"Completed count: {continuations.Count}, time (ms): {1e3 * time0}");
Console.ReadKey();
}
public virtual void OnBeginDrag(PointerEventData eventData)
{
var hitDistance = 0f;
switch (eventData.button)
{
case PointerEventData.InputButton.Middle:
case PointerEventData.InputButton.Right:
hitDistance = Mathf.Min(eventData.pointerPressRaycast.distance, m_initGrabDistance);
break;
case PointerEventData.InputButton.Left:
hitDistance = eventData.pointerPressRaycast.distance;
break;
default:
return;
}
var grabber = Grabber.Get(eventData);
grabber.grabber2hit = new RigidPose(new Vector3(0f, 0f, hitDistance), Quaternion.identity);
grabber.hit2pivot = RigidPose.FromToPose(grabber.grabberOrigin * grabber.grabber2hit, new RigidPose(transform));
if (m_eventGrabberSet == null)
{
m_eventGrabberSet = new IndexedTable <PointerEventData, Grabber>();
}
m_eventGrabberSet.Add(eventData, grabber);
AddGrabber(grabber);
}
public virtual void OnColliderEventDragStart(ColliderButtonEventData eventData)
{
if ((gameObject.tag.IndexOf("plant") == -1) || (gameObject.tag.IndexOf("plant") != -1 && Manager.Instance.IsFruitReady(Int32.Parse(gameObject.tag[gameObject.tag.Length - 1].ToString()))))
{
if (eventData.button != m_grabButton)
{
return;
}
var casterPose = GetEventPose(eventData);
var offsetPose = RigidPose.FromToPose(casterPose, new RigidPose(transform));
if (alignPosition)
{
offsetPose.pos = Vector3.zero;
}
if (alignRotation)
{
offsetPose.rot = Quaternion.identity;
}
if (eventData != grabbedEvent && beforeRelease != null)
{
beforeRelease.Invoke(this);
}
eventList.AddUniqueKey(eventData, offsetPose);
if (afterGrabbed != null)
{
afterGrabbed.Invoke(this);
}
}
}
private void UpdateMainCamTracking()
{
if (VIUSettings.simulatorAutoTrackMainCamera)
{
if (!m_autoTrackMainCam)
{
m_autoTrackMainCam = true;
m_mainCamStartPose = new RigidPose(Camera.main.transform, true);
}
if (Camera.main != null)
{
var hmd = VRModule.GetDeviceState(VRModule.HMD_DEVICE_INDEX);
if (hmd.isConnected)
{
RigidPose.SetPose(Camera.main.transform, hmd.pose);
}
}
}
else
{
if (m_autoTrackMainCam)
{
m_autoTrackMainCam = false;
if (Camera.main != null)
{
RigidPose.SetPose(Camera.main.transform, m_mainCamStartPose);
}
}
}
}
public override void Initialize(ContentArchive content, Camera camera)
{
camera.Position = new Vector3(-13f, 6, -13f);
camera.Yaw = MathF.PI * 3f / 4;
camera.Pitch = MathF.PI * 0.05f;
Simulation = Simulation.Create(BufferPool, new DemoNarrowPhaseCallbacks(), new DemoPoseIntegratorCallbacks(new Vector3(0, -10, 0)));
{
var shapeA = new Cylinder(0.5f, 1f);
var poseA = new RigidPose(new Vector3(0, 0, 0));
var shapeB = new Cylinder(1f, 2f);
//var positionB = new Vector3(-0.2570486f, 1.780561f, -1.033215f);
//var localOrientationBMatrix = new Matrix3x3
//{
// X = new Vector3(0.9756086f, 0.1946615f, 0.101463f),
// Y = new Vector3(-0.1539477f, 0.9362175f, -0.3159063f),
// Z = new Vector3(-0.1564862f, 0.2925809f, 0.9433496f)
//};
//var positionB = new Vector3(-1.437585f, 0.386236f, -1.124907f);
var positionB = new Vector3(-0.437585f, 0.386236f, -.124907f);
var localOrientationBMatrix = new Matrix3x3
{
X = new Vector3(-0.7615921f, 0.001486331f, -0.648055f),
Y = new Vector3(0.6341797f, 0.2075436f, -0.7448099f),
Z = new Vector3(-0.1333926f, -0.9782246f, -0.1590062f)
};
//var poseB = new RigidPose(new Vector3(-0.2570486f, 1.780561f, -1.033215f), Quaternion.CreateFromAxisAngle(Vector3.Normalize(new Vector3(1, 1, 1)), MathF.PI * 0.35f));
var poseB = new RigidPose(positionB, Quaternion.CreateFromRotationMatrix(localOrientationBMatrix));
basePosition = default;
shapeLines = MinkowskiShapeVisualizer.CreateLines <Cylinder, CylinderWide, CylinderSupportFinder, Cylinder, CylinderWide, CylinderSupportFinder>(
shapeA, shapeB, poseA, poseB, 65536,
0.01f, new Vector3(0.4f, 0.4f, 0),
0.1f, new Vector3(0, 1, 0), default, basePosition, BufferPool);
private void UpdateRecenterButtonVisible()
{
if (!isActiveAndEnabled || m_recenterButton == null)
{
return;
}
if (ExternalCameraHook.Instance.isTrackingDevice)
{
m_recenterButton.gameObject.SetActive(false);
}
else
{
bool needRecenter;
var origin = ExternalCameraHook.Instance.origin;
if (origin == null)
{
needRecenter = new RigidPose(ExternalCameraHook.Instance.transform, false) != RigidPose.identity;
}
else
{
needRecenter = new RigidPose(ExternalCameraHook.Instance.transform, false) != new RigidPose(origin, false);
}
m_recenterButton.gameObject.SetActive(needRecenter);
}
}
public virtual void OnDrag(PointerEventData eventData)
{
if (eventData != draggedEvent)
{
return;
}
if (!moveByVelocity)
{
// if rigidbody doen't exist, just move transform to eventData caster's pose
var casterPose = GetEventPose(eventData);
var offsetPose = eventList.GetLastValue();
m_prevPose = new RigidPose(transform);
if (rigid != null)
{
rigid.velocity = Vector3.zero;
rigid.angularVelocity = Vector3.zero;
}
var targetPose = casterPose * offsetPose;
transform.position = targetPose.pos;
transform.rotation = targetPose.rot;
}
}
static BodyReference AddBody <TShape>(TShape shape, float mass, RigidPose pose, Simulation simulation) where TShape : struct, IConvexShape
{
var shapeIndex = simulation.Shapes.Add(shape);
shape.ComputeInertia(mass, out var inertia);
var description = new BodyDescription
{
Activity = new BodyActivityDescription {
SleepThreshold = 0, MinimumTimestepCountUnderThreshold = 32
},
Collidable = new CollidableDescription
{
Continuity = new ContinuousDetectionSettings {
Mode = ContinuousDetectionMode.Discrete
},
SpeculativeMargin = .1f,
//Note that this always registers a new shape instance. You could be more clever/efficient and share shapes, but the goal here is to show the most basic option.
//Also, the cost of registering different shapes isn't that high for tiny implicit shapes.
Shape = shapeIndex
},
LocalInertia = inertia,
Pose = pose
};
return(new BodyReference(simulation.Bodies.Add(description), simulation.Bodies));
}
public override void ModifyPose(ref RigidPose pose, Transform origin)
{
if (firstPose)
{
firstPose = false;
}
else
{
Vector3 posDiff = prevPose.pos - pose.pos;
if (positionThreshold > 0f || posDiff.sqrMagnitude > positionThreshold * positionThreshold)
{
pose.pos = pose.pos + Vector3.ClampMagnitude(posDiff, positionThreshold);
}
else
{
pose.pos = prevPose.pos;
}
if (rotationThreshold > 0f || Quaternion.Angle(pose.rot, prevPose.rot) > rotationThreshold)
{
pose.rot = Quaternion.RotateTowards(pose.rot, prevPose.rot, rotationThreshold);
}
else
{
pose.rot = prevPose.rot;
}
}
prevPose = pose;
}
public Grabber(IColliderEventCaster eventCaster, GameObject obj)
{
Debug.Log(3);
this.eventCaster = eventCaster;
this.grabbingObj = obj;
this.grabOffset = RigidPose.FromToPose(new RigidPose(eventCaster.transform), new RigidPose(obj.transform));
}
public virtual void OnColliderEventDragStart(ColliderButtonEventData eventData)
{
if (eventData.button != m_grabButton)
{
return;
}
if (!m_allowMultipleGrabbers)
{
ClearGrabbers(false);
ClearEventGrabberSet();
}
var grabber = Grabber.Get(eventData);
var offset = RigidPose.FromToPose(grabber.grabberOrigin, new RigidPose(transform));
if (alignPosition)
{
offset.pos = alignPositionOffset;
}
if (alignRotation)
{
offset.rot = Quaternion.Euler(alignRotationOffset);
}
grabber.grabOffset = offset;
if (m_eventGrabberSet == null)
{
m_eventGrabberSet = new IndexedTable <ColliderButtonEventData, Grabber>();
}
m_eventGrabberSet.Add(eventData, grabber);
AddGrabber(grabber);
}
public virtual void OnColliderEventPressDown(ColliderButtonEventData eventData)
{
GrabData grabData;
if (eventData.button != m_grabButton)
{
return;
}
if (eventList.TryGetValue(eventData, out grabData))
{
switch (grabData.grabState)
{
case EventGrabState.JustReleased:
eventList.Remove(eventData);
if (m_toggleReleaseCheckedFrame == Time.frameCount)
{
// skip when this event just released at the same frame
return;
}
break;
case EventGrabState.JustGrabbed:
case EventGrabState.Grabbing:
default:
return;
}
}
if (!m_multipleGrabbers)
{
Release();
}
var casterPose = GetEventPose(eventData);
var offsetPose = RigidPose.FromToPose(casterPose, new RigidPose(transform));
if (alignPosition)
{
offsetPose.pos = Vector3.zero;
}
if (alignRotation)
{
offsetPose.rot = Quaternion.identity;
}
grabData = new GrabData()
{
offset = offsetPose,
grabState = isToggleReleaseCheckedThisFrame ? EventGrabState.Grabbing : EventGrabState.JustGrabbed,
};
eventList.AddUniqueKey(eventData, grabData);
if (afterGrabbed != null)
{
afterGrabbed.Invoke(this);
}
}
private void Start()
{
resetPoses = new RigidPose[effectTargets.Length];
for (int i = 0; i < effectTargets.Length; ++i)
{
resetPoses[i] = new RigidPose(effectTargets[i]);
}
}
static void CreateBallSocket(ref RigidPose a, ref RigidPose b, out BallSocket description)
{
var midpoint = 0.5f * (a.Position + b.Position);
description.LocalOffsetA = QuaternionEx.Transform(midpoint - a.Position, QuaternionEx.Conjugate(a.Orientation));
description.LocalOffsetB = QuaternionEx.Transform(midpoint - b.Position, QuaternionEx.Conjugate(b.Orientation));
description.SpringSettings = new SpringSettings(15, 0.1f);
}
private static void UpdateDeviceJoints(IVRModuleDeviceStateRW state, Vector3[] rawJoints, bool isLeft)
{
var hmdPose = VRModule.GetDeviceState(VRModule.HMD_DEVICE_INDEX).pose;
GestureInterface.SetCameraTransform(hmdPose.pos, hmdPose.rot);
var roomSpaceWrist2index = rawJoints[5] - rawJoints[0];
var roomSpaceWrist2middle = rawJoints[9] - rawJoints[0];
var roomSpaceWrist2pinky = rawJoints[17] - rawJoints[0];
var roomSpaceWristUp = isLeft ? Vector3.Cross(roomSpaceWrist2pinky, roomSpaceWrist2index) : Vector3.Cross(roomSpaceWrist2index, roomSpaceWrist2pinky);
var roomSpaceWristPose = new RigidPose(rawJoints[0], Quaternion.LookRotation(roomSpaceWrist2middle, roomSpaceWristUp));
state.pose = roomSpaceWristPose;
state.handJoints[HandJointName.Wrist] = new JointPose(roomSpaceWristPose);
state.handJoints[HandJointName.Palm] = new JointPose(new RigidPose((rawJoints[0] + rawJoints[9]) * 0.5f, roomSpaceWristPose.rot));
var camSpaceFingerRight = roomSpaceWristPose.rot * Vector3.right;
Quaternion roomSpaceRot;
roomSpaceRot = CalculateJointRot(rawJoints, 1, 2, roomSpaceWristPose.rot * (isLeft ? new Vector3(0.1f, -5.67f, -0.1f) : new Vector3(0.1f, 5.67f, 0.1f)));
state.handJoints[HandJointName.ThumbMetacarpal] = new JointPose(new RigidPose(rawJoints[1], roomSpaceRot));
roomSpaceRot = CalculateJointRot(rawJoints, 2, 3, roomSpaceWristPose.rot * (isLeft ? new Vector3(0.1f, -5.67f, -0.1f) : new Vector3(0.1f, 5.67f, 0.1f)));
state.handJoints[HandJointName.ThumbProximal] = new JointPose(new RigidPose(rawJoints[2], roomSpaceRot));
roomSpaceRot = CalculateJointRot(rawJoints, 3, 4, roomSpaceWristPose.rot * (isLeft ? new Vector3(1.72f, -5.67f, -3.55f) : new Vector3(1.72f, 5.67f, 3.55f)));
state.handJoints[HandJointName.ThumbDistal] = new JointPose(new RigidPose(rawJoints[3], roomSpaceRot));
state.handJoints[HandJointName.ThumbTip] = new JointPose(new RigidPose(rawJoints[4], roomSpaceRot));
roomSpaceRot = CalculateJointRot(rawJoints, 5, 6, camSpaceFingerRight);
state.handJoints[HandJointName.IndexProximal] = new JointPose(new RigidPose(rawJoints[5], roomSpaceRot));
roomSpaceRot = CalculateJointRot(rawJoints, 6, 7, camSpaceFingerRight);
state.handJoints[HandJointName.IndexIntermediate] = new JointPose(new RigidPose(rawJoints[6], roomSpaceRot));
roomSpaceRot = CalculateJointRot(rawJoints, 7, 8, camSpaceFingerRight);
state.handJoints[HandJointName.IndexDistal] = new JointPose(new RigidPose(rawJoints[7], roomSpaceRot));
state.handJoints[HandJointName.IndexTip] = new JointPose(new RigidPose(rawJoints[8], roomSpaceRot));
roomSpaceRot = CalculateJointRot(rawJoints, 9, 10, camSpaceFingerRight);
state.handJoints[HandJointName.MiddleProximal] = new JointPose(new RigidPose(rawJoints[9], roomSpaceRot));
roomSpaceRot = CalculateJointRot(rawJoints, 10, 11, camSpaceFingerRight);
state.handJoints[HandJointName.MiddleIntermediate] = new JointPose(new RigidPose(rawJoints[10], roomSpaceRot));
roomSpaceRot = CalculateJointRot(rawJoints, 11, 12, camSpaceFingerRight);
state.handJoints[HandJointName.MiddleDistal] = new JointPose(new RigidPose(rawJoints[11], roomSpaceRot));
state.handJoints[HandJointName.MiddleTip] = new JointPose(new RigidPose(rawJoints[12], roomSpaceRot));
roomSpaceRot = CalculateJointRot(rawJoints, 13, 14, camSpaceFingerRight);
state.handJoints[HandJointName.RingProximal] = new JointPose(new RigidPose(rawJoints[13], roomSpaceRot));
roomSpaceRot = CalculateJointRot(rawJoints, 14, 15, camSpaceFingerRight);
state.handJoints[HandJointName.RingIntermediate] = new JointPose(new RigidPose(rawJoints[14], roomSpaceRot));
roomSpaceRot = CalculateJointRot(rawJoints, 15, 16, camSpaceFingerRight);
state.handJoints[HandJointName.RingDistal] = new JointPose(new RigidPose(rawJoints[15], roomSpaceRot));
state.handJoints[HandJointName.RingTip] = new JointPose(new RigidPose(rawJoints[16], roomSpaceRot));
roomSpaceRot = CalculateJointRot(rawJoints, 17, 18, camSpaceFingerRight);
state.handJoints[HandJointName.PinkyProximal] = new JointPose(new RigidPose(rawJoints[17], roomSpaceRot));
roomSpaceRot = CalculateJointRot(rawJoints, 18, 19, camSpaceFingerRight);
state.handJoints[HandJointName.PinkyIntermediate] = new JointPose(new RigidPose(rawJoints[18], roomSpaceRot));
roomSpaceRot = CalculateJointRot(rawJoints, 19, 20, camSpaceFingerRight);
state.handJoints[HandJointName.PinkyDistal] = new JointPose(new RigidPose(rawJoints[19], roomSpaceRot));
state.handJoints[HandJointName.PinkyTip] = new JointPose(new RigidPose(rawJoints[20], roomSpaceRot));
}
public override void ModifyPose(ref RigidPose pose, Transform origin)
{
Vector3 freezePos;
Vector3 freezeEuler;
if (freezePositionX || freezePositionY || freezePositionZ)
{
if (origin != null && origin != transform.parent)
{
freezePos = origin.InverseTransformPoint(transform.position);
}
else
{
freezePos = transform.localPosition;
}
if (freezePositionX)
{
pose.pos.x = freezePos.x;
}
if (freezePositionY)
{
pose.pos.y = freezePos.y;
}
if (freezePositionZ)
{
pose.pos.z = freezePos.z;
}
}
if (freezeRotationX || freezeRotationY || freezeRotationZ)
{
if (origin != null && origin != transform.parent)
{
freezeEuler = (Quaternion.Inverse(origin.rotation) * transform.rotation).eulerAngles;
}
else
{
freezeEuler = transform.localEulerAngles;
}
var poseEuler = pose.rot.eulerAngles;
if (freezeRotationX)
{
poseEuler.x = freezeEuler.x;
}
if (freezeRotationY)
{
poseEuler.y = freezeEuler.y;
}
if (freezeRotationZ)
{
poseEuler.z = freezeEuler.z;
}
pose.rot = Quaternion.Euler(poseEuler);
}
}
protected void OnGrabRigidbody()
{
var targetPose = currentGrabber.grabberOrigin * currentGrabber.grabOffset;
ModifyPose(ref targetPose, null);
RigidPose.SetRigidbodyVelocity(grabRigidbody, grabRigidbody.position, targetPose.pos, followingDuration);
RigidPose.SetRigidbodyAngularVelocity(grabRigidbody, grabRigidbody.rotation, targetPose.rot, followingDuration, overrideMaxAngularVelocity);
}
public override void ModifyPose(ref RigidPose pose, Transform origin)
{
if (firstPose)
{
firstPose = false;
}
else
{
var deltaTime = Time.unscaledDeltaTime;
if (deltaTime < duration)
{
var easedPose = RigidPose.Lerp(prevPose, pose, curve.Evaluate(deltaTime / duration));
if (!easePositionX || !easePositionY || !easePositionZ)
{
var originPos = pose.pos;
var easedPos = easedPose.pos;
if (!easePositionX)
{
easedPos.x = originPos.x;
}
if (!easePositionY)
{
easedPos.y = originPos.y;
}
if (!easePositionZ)
{
easedPos.z = originPos.z;
}
easedPose.pos = easedPos;
}
if (!easeRotationX || !easeRotationY || !easeRotationZ)
{
var originEuler = pose.rot.eulerAngles;
var easedEuler = easedPose.rot.eulerAngles;
if (!easeRotationX)
{
easedEuler.x = originEuler.x;
}
if (!easeRotationY)
{
easedEuler.y = originEuler.y;
}
if (!easeRotationZ)
{
easedEuler.z = originEuler.z;
}
easedPose.rot = Quaternion.Euler(easedEuler);
}
pose = easedPose;
}
}
prevPose = pose;
}
