/// <summary>
/// Starts dragging the object.
/// </summary>
public void StartDragging()
{
if (!IsDraggingEnabled)
{
return;
}
if (isDragging)
{
return;
}
// Add self as a modal input handler, to get all inputs during the manipulation
InputManager.Instance.PushModalInputHandler(gameObject);
isDragging = true;
//GazeCursor.Instance.SetState(GazeCursor.State.Move);
//GazeCursor.Instance.SetTargetObject(HostTransform);
Vector3 gazeHitPosition = GazeManager.Instance.HitInfo.point;
Vector3 handPosition;
currentInputSource.TryGetPosition(currentInputSourceId, out handPosition);
//Debug.Log("Hand Position " + handPosition);
Vector3 pivotPosition = GetHandPivotPosition();
handRefDistance = Vector3.Magnitude(handPosition - pivotPosition);
objRefDistance = Vector3.Magnitude(gazeHitPosition - pivotPosition);
Vector3 objForward = HostTransform.forward;
Vector3 objUp = HostTransform.up;
// Store where the object was grabbed from
objRefGrabPoint = mainCamera.transform.InverseTransformDirection(HostTransform.position - gazeHitPosition);
Vector3 objDirection = Vector3.Normalize(gazeHitPosition - pivotPosition);
Vector3 handDirection = Vector3.Normalize(handPosition - pivotPosition);
objForward = mainCamera.transform.InverseTransformDirection(objForward); // in camera space
objUp = mainCamera.transform.InverseTransformDirection(objUp); // in camera space
objDirection = mainCamera.transform.InverseTransformDirection(objDirection); // in camera space
handDirection = mainCamera.transform.InverseTransformDirection(handDirection); // in camera space
objRefForward = objForward;
objRefUp = objUp;
// Store the initial offset between the hand and the object, so that we can consider it when dragging
gazeAngularOffset = Quaternion.FromToRotation(handDirection, objDirection);
draggingPosition = gazeHitPosition;
StartedDragging.RaiseEvent();
//hide some objects while dragging
for (int i = 0; i < objectsToHide.Length; i++)
{
objectsToHide[i].SetActive(false); //or renderer instead?
}
}
/// <summary>
/// Starts dragging the object.
/// </summary>
public void StartDragging()
{
if (isDragging)
{
return;
}
// Add self as a modal input handler, to get all inputs during the manipulation
InputManager.Instance.PushModalInputHandler(gameObject);
isDragging = true;
//GazeCursor.Instance.SetState(GazeCursor.State.Move);
//GazeCursor.Instance.SetTargetObject(HostTransform);
// Vector3 gazeHitPosition = GazeManager.Instance.HitInfo.point;
currentInputSource.TryGetPosition(currentInputSourceId, out startHandPosition);
handPosition = startHandPosition;
// Spawn Pokeball
pokeballInstance = Instantiate(throwObjectPrefab, startHandPosition, Camera.main.transform.rotation);
pokeballInstance.GetComponent <Collider>().enabled = false;
aiming = true;
//draggingPosition = gazeHitPosition;
StartedDragging.RaiseEvent();
}
/// <summary>
/// Uniform code for different types of manipulation complete (stopped, source lost, etc..)
/// </summary>
private void HandleRelease(bool lost)
{
mTempInputSource = null;
Vector3 handPosition;
mCurrentInputSource.TryGetPosition(mCurrentInputSourceId, out handPosition);
mCurrentHandPosition = handPosition;
Control.ManipulationUpdate(
mStartHandPosition,
mCurrentHandPosition,
mStartHeadPosition,
mStartHeadRay,
lost ? GestureManipulationState.Lost : GestureManipulationState.None);
InputManager.Instance.ClearModalInputStack();
if (HasGaze)
{
base.OnInputUp(null);
}
else
{
base.OnInputUp(null);
base.OnFocusExit();
}
mCurrentInputSource = null;
HandleCursor(false);
}
private void StartTransform()
{
InputManager.Instance.PushModalInputHandler(gameObject);
isTransforming = true;
Vector3 gazeHitPosition = GazeManager.Instance.HitInfo.point;
Vector3 handPosition;
currentInputSource.TryGetPosition(currentInputSourceId, out handPosition);
Vector3 pivotPosition = GetHandPivotPosition();
handRefDistance = Vector3.Magnitude(handPosition - pivotPosition);
objRefDistance = Vector3.Magnitude(gazeHitPosition - pivotPosition);
objRefGrabPoint = mainCamera.transform.InverseTransformDirection(HostTransform.position - gazeHitPosition);
Vector3 objForward = HostTransform.forward;
Vector3 objDirection = Vector3.Normalize(gazeHitPosition - pivotPosition);
Vector3 handDirection = Vector3.Normalize(handPosition - pivotPosition);
objForward = mainCamera.transform.InverseTransformDirection(objForward);
objDirection = mainCamera.transform.InverseTransformDirection(objDirection);
handDirection = mainCamera.transform.InverseTransformDirection(handDirection);
objRefForward = objForward;
gazeAngularOffset = Quaternion.FromToRotation(handDirection, objDirection);
draggingPosition = gazeHitPosition;
StartedTransformation.RaiseEvent();
}
/// <summary>
/// Starts dragging the object.
/// </summary>
private void StartDragging()
{
if (isDragging)
{
return;
}
StopPlacingWithGaze();
isDragging = true;
Vector3 gazeHitPosition = GazeManager.Instance.HitInfo.point;
Vector3 handPosition;
currentInputSource.TryGetPosition(currentInputSourceId, out handPosition);
Vector3 pivotPosition = GetHandPivotPosition();
Vector3 objDirection = Vector3.Normalize(gazeHitPosition - pivotPosition);
Vector3 handDirection = Vector3.Normalize(handPosition - pivotPosition);
objDirection = Camera.main.transform.InverseTransformDirection(objDirection);
handDirection = Camera.main.transform.InverseTransformDirection(handDirection);
// Store the initial offset between the hand and the object, so that we can consider it when dragging.
gazeAngularOffset = Quaternion.FromToRotation(handDirection, objDirection);
StartedDragging.RaiseEvent();
}
public void StartDragging()
{
if (!IsDraggingEnable)
{
return;
}
if (isDragging)
{
return;
}
InputManager.Instance.PushModalInputHandler(gameObject);
isDragging = true;
Vector3 targetPosition = target.transform.position;
Vector3 handPosition;
currentInputSource.TryGetPosition(currentInputSourceId, out handPosition);
Vector3 pivotPosition = GetHandPivotPosition();
handRefDistance = Vector3.Magnitude(handPosition - pivotPosition);
objRefDistance = Vector3.Magnitude(targetPosition - pivotPosition);
Vector3 objDirection = Vector3.Normalize(targetPosition - pivotPosition);
Vector3 handDirection = Vector3.Normalize(handPosition - pivotPosition);
objDirection = mainCamera.transform.InverseTransformDirection(objDirection);
handDirection = mainCamera.transform.InverseTransformDirection(handDirection);
gazeAngularOffset = Quaternion.FromToRotation(handDirection, objDirection);
draggingPosition = targetPosition;
}
/// <summary>
/// Starts dragging the object.
/// </summary>
public void StartDragging()
{
if (!IsDraggingEnabled)
{
return;
}
if (isDragging)
{
return;
}
if (!gameObject.GetComponent <Rigidbody>())
{
gameObject.AddComponent <Rigidbody>();
gameObject.GetComponent <Rigidbody>().mass = 0.5f;
}
gameObject.GetComponent <Rigidbody>().useGravity = false;
// Add self as a modal input handler, to get all inputs during the manipulation
InputManager.Instance.PushModalInputHandler(gameObject);
isDragging = true;
//GazeCursor.Instance.SetState(GazeCursor.State.Move);
//GazeCursor.Instance.SetTargetObject(HostTransform);
Vector3 gazeHitPosition = GazeManager.Instance.HitInfo.point;
Vector3 handPosition;
currentInputSource.TryGetPosition(currentInputSourceId, out handPosition);
Vector3 pivotPosition = GetHandPivotPosition();
handRefDistance = Vector3.Magnitude(handPosition - pivotPosition);
objRefDistance = Vector3.Magnitude(gazeHitPosition - pivotPosition);
Vector3 objForward = HostTransform.forward;
Vector3 objUp = HostTransform.up;
// Store where the object was grabbed from
objRefGrabPoint = mainCamera.transform.InverseTransformDirection(HostTransform.position - gazeHitPosition);
Vector3 objDirection = Vector3.Normalize(gazeHitPosition - pivotPosition);
Vector3 handDirection = Vector3.Normalize(handPosition - pivotPosition);
objForward = mainCamera.transform.InverseTransformDirection(objForward); // in camera space
objUp = mainCamera.transform.InverseTransformDirection(objUp); // in camera space
objDirection = mainCamera.transform.InverseTransformDirection(objDirection); // in camera space
handDirection = mainCamera.transform.InverseTransformDirection(handDirection); // in camera space
objRefForward = objForward;
objRefUp = objUp;
// Store the initial offset between the hand and the object, so that we can consider it when dragging
gazeAngularOffset = Quaternion.FromToRotation(handDirection, objDirection);
draggingPosition = gazeHitPosition;
StartedDragging.RaiseEvent();
}
public void StartDragging()
{
if (!IsDraggingEnable)
{
return;
}
if (isDragging)
{
return;
}
InputManager.Instance.PushModalInputHandler(gameObject);
isDragging = true;
currentInputSource.TryGetPosition(currentInputSourceId, out startHandPosition);
scaleAxisVect = transform.position - tc.transform.position;
scaleAxisVect.Normalize();
targetBaseScale = target.transform.localScale;
startTransformControllerPosition = tc.transform.position;
startDistance = Vector3.Distance(startTransformControllerPosition, transform.position);
startTargetPosition = target.transform.position;
startDiffPivotToCenter = startTargetPosition - startTransformControllerPosition;
}
/// <summary>
/// Starts dragging the object.
/// </summary>
public void StartRotating()
{
if (!IsRotatingEnabled)
{
return;
}
if (isRotating)
{
return;
}
// Add self as a modal input handler, to get all inputs during the manipulation
InputManager.Instance.PushModalInputHandler(gameObject);
isRotating = true;
Vector3 handPosition;
currentInputSource.TryGetPosition(currentInputSourceId, out handPosition);
// Store the initial offset between the hand and the object, so that we can consider it when dragging
startRotation = HostTransform.rotation;
startHandPosition = handPosition;
startDir = Vector3.Normalize(HostTransform.position - handPosition);
StartedRotating.RaiseEvent();
}
void Update()
{
if (isRotating)
{
currentInputSource.TryGetPosition(currentInputSourceId, out handPosition);
rotationFactor = handPosition.x * RotationSensitivity;
transform.Rotate(new Vector3(0, -1 * rotationFactor, 0));
}
}
/// <summary>
/// Starts dragging the object.
/// </summary>
public void StartDragging()
{
if (!IsDraggingEnabled)
{
return;
}
if (isDragging)
{
return;
}
// Add self as a modal input handler, to get all inputs during the manipulation
InputManager.Instance.PushModalInputHandler(gameObject);
isDragging = true;
Vector3 gazeHitPosition = GazeManager.Instance.HitInfo.point;
Vector3 handPosition;
currentInputSource.TryGetPosition(currentInputSourceId, out handPosition);
Vector3 pivotPosition = GetHandPivotPosition();
handRefDistance = Vector3.Magnitude(handPosition - pivotPosition);
objRefDistance = Vector3.Magnitude(gazeHitPosition - pivotPosition);
Vector3 objForward = HostTransform.forward;
Vector3 objUp = HostTransform.up;
// Store where the object was grabbed from
objRefGrabPoint = mainCamera.transform.InverseTransformDirection(HostTransform.position - gazeHitPosition);
Vector3 objDirection = Vector3.Normalize(gazeHitPosition - pivotPosition);
Vector3 handDirection = Vector3.Normalize(handPosition - pivotPosition);
objForward = mainCamera.transform.InverseTransformDirection(objForward); // in camera space
objUp = mainCamera.transform.InverseTransformDirection(objUp); // in camera space
objDirection = mainCamera.transform.InverseTransformDirection(objDirection); // in camera space
handDirection = mainCamera.transform.InverseTransformDirection(handDirection); // in camera space
objRefForward = objForward;
objRefUp = objUp;
// Store the initial offset between the hand and the object, so that we can consider it when dragging
gazeAngularOffset = Quaternion.FromToRotation(handDirection, objDirection);
draggingPosition = gazeHitPosition;
if (popupMenu)
{
popupMenu.parent = transform;
popupMenu.gameObject.SetActive(false);
}
StartedDragging.RaiseEvent();
}
/// <summary>
/// Starts dragging the object.
/// </summary>
public void StartDragging()
{
if (!IsDraggingEnabled)
{
return;
}
if (isDragging)
{
Debug.Log("Still Dragging " + this.name);
return;
}
// Add self as a modal input handler, to get all inputs during the manipulation
InputManager.Instance.PushModalInputHandler(gameObject);
isDragging = true;
Debug.Log("Starting Dragging " + this.name);
GameObject.Find("StageCollection").SendMessage("UpdateDragging", this.name);
//GazeCursor.Instance.SetState(GazeCursor.State.Move);
//GazeCursor.Instance.SetTargetObject(HostTransform);
Vector3 gazeHitPosition = GazeManager.Instance.HitInfo.point;
Vector3 handPosition;
currentInputSource.TryGetPosition(currentInputSourceId, out handPosition);
Vector3 pivotPosition = GetHandPivotPosition();
handRefDistance = Vector3.Magnitude(handPosition - pivotPosition);
objRefDistance = Vector3.Magnitude(gazeHitPosition - pivotPosition);
Vector3 objForward = HostTransform.forward;
// Store where the object was grabbed from
objRefGrabPoint = mainCamera.transform.InverseTransformDirection(HostTransform.position - gazeHitPosition);
Vector3 objDirection = Vector3.Normalize(gazeHitPosition - pivotPosition);
Vector3 handDirection = Vector3.Normalize(handPosition - pivotPosition);
objForward = mainCamera.transform.InverseTransformDirection(objForward); // in camera space
objDirection = mainCamera.transform.InverseTransformDirection(objDirection); // in camera space
handDirection = mainCamera.transform.InverseTransformDirection(handDirection); // in camera space
objRefForward = objForward;
// Store the initial offset between the hand and the object, so that we can consider it when dragging
gazeAngularOffset = Quaternion.FromToRotation(handDirection, objDirection);
draggingPosition = gazeHitPosition;
StartedDragging.RaiseEvent();
}
/// <summary>
/// Starts dragging the object.
/// </summary>
public void StartDragging(Vector3 initialDraggingPosition)
{
if (!IsDraggingEnabled)
{
return;
}
if (isDragging)
{
return;
}
// TODO: robertes: Fix push/pop and single-handler model so that multiple HandDraggable components
// can be active at once.
// Add self as a modal input handler, to get all inputs during the manipulation
InputManager.Instance.PushModalInputHandler(gameObject);
isDragging = true;
//GazeCursor.Instance.SetState(GazeCursor.State.Move);
//GazeCursor.Instance.SetTargetObject(HostTransform);
Vector3 handPosition;
currentInputSource.TryGetPosition(currentInputSourceId, out handPosition);
Vector3 pivotPosition = GetHandPivotPosition();
handRefDistance = Vector3.Magnitude(handPosition - pivotPosition);
objRefDistance = Vector3.Magnitude(initialDraggingPosition - pivotPosition);
Vector3 objForward = HostTransform.forward;
// Store where the object was grabbed from
objRefGrabPoint = mainCamera.transform.InverseTransformDirection(HostTransform.position - initialDraggingPosition);
Vector3 objDirection = Vector3.Normalize(initialDraggingPosition - pivotPosition);
Vector3 handDirection = Vector3.Normalize(handPosition - pivotPosition);
objForward = mainCamera.transform.InverseTransformDirection(objForward); // in camera space
objDirection = mainCamera.transform.InverseTransformDirection(objDirection); // in camera space
handDirection = mainCamera.transform.InverseTransformDirection(handDirection); // in camera space
objRefForward = objForward;
// Store the initial offset between the hand and the object, so that we can consider it when dragging
gazeAngularOffset = Quaternion.FromToRotation(handDirection, objDirection);
draggingPosition = initialDraggingPosition;
StartedDragging.RaiseEvent();
}
public void OnInputDown(InputEventData eventData)
{
isDown = false;
Vector3 pos;
inputSource = eventData.InputSource;
inputSourceId = eventData.SourceId;
Debug.Log(inputSourceId);
inputSource.TryGetPosition(inputSourceId, out pos);
pos += cam.transform.rotation * InputOffset;
//Debug.Log(pos);
Ray inputRay = new Ray(cam.transform.position, pos - cam.transform.position);
RaycastHit hit;
var colliders = Physics.OverlapSphere(pos, 0.1f);
if (colliders.Length > 0)
{
Draggable draggable = colliders[0].gameObject.GetComponent <Draggable>();
if (draggable)
{
interacted = colliders[0].gameObject;
draggable.updateInputPos(pos);
draggable.onInputDown();
isDown = true;
}
}
}
/// <summary>
/// Starts scaling the object with the given input source.
/// </summary>
public void StartScaling(IInputSource inputSource, uint inputSourceId)
{
if (isScaling)
{
return;
}
if (inputSource == null || !inputSource.SupportsInputInfo(inputSourceId, SupportedInputInfo.Position))
{
Debug.Log("The provided input source does not support the required positional info.");
return;
}
currentInputSource = inputSource;
currentInputSourceId = inputSourceId;
// Add self as a modal input handler, to get all inputs during the manipulation.
InputManager.Instance.PushModalInputHandler(gameObject);
currentInputSource.TryGetPosition(currentInputSourceId, out prevHandPosition);
grabPoint = prevHandPosition;
scaleUpVector = Vector3.Normalize(grabPoint - TargetGameObject.transform.position);
isScaling = true;
StartedScaling.RaiseEvent();
}
void UpdateRotation()
{
Vector3 newHandA, newHandB;
handAInputSource.TryGetPosition(handASourceId, out newHandA);
handBInputSource.TryGetPosition(handBSourceId, out newHandB);
float newHandLineSlope = (newHandA.y - newHandB.y) / (newHandA.x - newHandB.x);
float oldHandLineSlope = (handAPos.y - handBPos.y) / (handAPos.x - handBPos.x);
float newRotation = (float)Math.Atan(newHandLineSlope);
float oldRotation = (float)Math.Atan(oldHandLineSlope);
float deltaRotation = 180 * (newRotation - oldRotation) / (float)Math.PI;
if (float.IsNaN(deltaRotation))
{
return;
}
armRotation -= deltaRotation;
if (logging)
{
Debug.Log("Rotate: Object angle " + thermostatArm.transform.eulerAngles.z + " at " + Time.time);
Debug.Log("Rotate: Hand A: " + newHandA.x + "," + newHandA.y + "," + newHandA.z + " at " + Time.time);
Debug.Log("Rotate: Hand B: " + newHandB.x + "," + newHandB.y + "," + newHandB.z + " at " + Time.time);
}
handAPos = newHandA;
handBPos = newHandB;
}
public void OnInputDown(InputEventData eventData)
{
if (ExperimentManager.Instance.IsOnCountdown())
{
return;
}
if (!eventData.InputSource.SupportsInputInfo(eventData.SourceId, SupportedInputInfo.Position))
{
// The input source must provide positional data for this script to be usable
return;
}
if (RepositionManager.Instance.GetWallStatusMode(instanceId) == WallStatusModes.DRAGGING)
{
// We're already handling drag input, so we can't start a new drag operation.
return;
}
if (RepositionManager.Instance.GetWallStatusMode(instanceId) == WallStatusModes.IDLE)
{
currentInputSource = eventData.InputSource;
currentInputSourceId = eventData.SourceId;
// Add self as a modal input handler, to get all inputs during the manipulation
InputManager.Instance.AddMultiModalInputHandler(currentInputSourceId, gameObject);
RepositionManager.Instance.SetWallMode(gameObject, WallStatusModes.DRAGGING);
// calculate initial positions
Vector3 initialHandPosition;
currentInputSource.TryGetPosition(currentInputSourceId, out initialHandPosition);
initialObjPosition = HostTransform.position;
lockedObjPosition = HostTransform.position;
initialHandVector = initialHandPosition - mainCamera.transform.position;
prevHandPosition = initialHandPosition;
}
else if (RepositionManager.Instance.GetWallStatusMode(instanceId) == WallStatusModes.LOCKED)
{
if (Time.unscaledTime - lastInputUpTime < doubleTapDuration)
{
OnInputDoubleTapped(eventData);
}
else
{
currentInputSource = eventData.InputSource;
currentInputSourceId = eventData.SourceId;
// Add self as a modal input handler, to get all inputs during the manipulation
InputManager.Instance.AddMultiModalInputHandler(currentInputSourceId, gameObject);
RepositionManager.Instance.SetWallMode(gameObject, WallStatusModes.DRAGGING);
// calculate initial positions
Vector3 initialHandPosition;
currentInputSource.TryGetPosition(currentInputSourceId, out initialHandPosition);
lockedObjPosition = HostTransform.position;
initialHandVector = initialHandPosition - mainCamera.transform.position;
prevHandPosition = initialHandPosition;
}
}
}
/// <summary>
/// Update the position of the object being dragged.
/// </summary>
private void UpdateDragging()
{
//extract the only input source
IInputSource currentInputSource = currentInputSources.Values.ToArray()[0];
uint currentInputSourceId = handsPositions.Keys.ToArray()[0];
Vector3 newHandPosition;
currentInputSource.TryGetPosition(currentInputSourceId, out newHandPosition);
Vector3 pivotPosition = GetHandPivotPosition();
Vector3 newHandDirection = Vector3.Normalize(newHandPosition - pivotPosition);
newHandDirection = mainCamera.transform.InverseTransformDirection(newHandDirection); // in camera space
Vector3 targetDirection = Vector3.Normalize(gazeAngularOffset * newHandDirection);
targetDirection = mainCamera.transform.TransformDirection(targetDirection); // back to world space
float currenthandDistance = Vector3.Magnitude(newHandPosition - pivotPosition);
float distanceRatio = currenthandDistance / handRefDistance;
float distanceOffset = distanceRatio > 0 ? (distanceRatio - 1f) * DistanceScale : 0;
float targetDistance = objRefDistance + distanceOffset;
handsPositions[currentInputSourceId] = pivotPosition + (targetDirection * targetDistance);
// Apply Final Position
HostTransform.position = Vector3.Lerp(HostTransform.position, handsPositions[currentInputSourceId] + mainCamera.transform.TransformDirection(objRefGrabPoint), PositionLerpSpeed);
}
private Vector3 GetCurrentInputPosition()
{
Vector3 currentHandPos;
currentInputSource.TryGetPosition(currentInputSourceId, out currentHandPos);
return(currentHandPos);
}
// Update is called once per frame
void Update()
{
if (isDrag)
{
currentInputSource.TryGetPosition(id, out pos);
//Debug.Log(pos);
obj.transform.position = pos;
//CustomMessages.Instance.Send3dDraw(pos);
}
CustomMessages.Instance.Send3dDraw(pos, isDragShare);
RaycastHit hitInfo;
hit = Physics.Raycast(Camera.main.transform.position,
Camera.main.transform.forward,
out hitInfo,
20f);
if (hit && hitInfo.collider.tag == "DummyAnchor")
{
returnToMenuFlag = 1;
Debug.Log(hitInfo.collider.tag);
}
//CustomMessages.Instance.MessageHandlers[CustomMessages.TestMessageID.Draw3d] = Shared3dDraw;
}
public void OnInputDown(InputEventData eventData)
{
//Debug.Log("InputDown");
//hide the main cursor while selecting
mainCursor.SetVisiblity(false);
isHolding = true;
currInputSource = eventData.InputSource;
currInputSourceId = eventData.SourceId;
// Add self as a modal input handler, to get all inputs during the manipulation
InputManager.Instance.PushModalInputHandler(gameObject);
//save the first hit point
firstHitPoint = GazeManager.Instance.HitPosition;
forwardDir = Camera.main.transform.forward;
upDir = Camera.main.transform.up;
rightDir = Vector3.Cross(upDir, forwardDir);
currInputSource.TryGetPosition(currInputSourceId, out firstHandPosition);
//initialise the currHandPosition
currHandPosition = firstHandPosition;
//put a dot cursor where we first hit the stone
dotRect.SetActive(true);
dotRect.transform.position = mainCursor.Dot.transform.position;
dotRect.transform.forward = mainCursor.Dot.transform.forward; // look at user
dotRect.transform.localScale = (originalDotScale * this.transform.localScale.x) / originalScale.x;
UpdateQuadVertices();
quad.SetActive(true);
}
void UpdateRotation()
{
Vector3 newHandA, newHandB;
handAInputSource.TryGetPosition(handASourceId, out newHandA);
handBInputSource.TryGetPosition(handBSourceId, out newHandB);
float newHandLineSlope = (newHandA.y - newHandB.y) / (newHandA.x - newHandB.x);
float oldHandLineSlope = (handAPos.y - handBPos.y) / (handAPos.x - handBPos.x);
float newRotation = (float)Math.Atan(newHandLineSlope);
float oldRotation = (float)Math.Atan(oldHandLineSlope);
float deltaRotation = 180 * (newRotation - oldRotation) / (float)Math.PI;
if (Math.Abs(deltaRotation) < 50)
{
zoomedImage.gameObject.transform.eulerAngles = new Vector3(zoomedImage.gameObject.transform.eulerAngles.x,
zoomedImage.gameObject.transform.eulerAngles.y,
zoomedImage.gameObject.transform.eulerAngles.z + deltaRotation);
if (logging)
{
Debug.Log("Rotate: Object angle " + zoomedImage.gameObject.transform.eulerAngles.z + " at " + Time.time);
Debug.Log("Rotate: Hand A: " + newHandA.x + "," + newHandA.y + "," + newHandA.z + " at " + Time.time);
Debug.Log("Rotate: Hand B: " + newHandB.x + "," + newHandB.y + "," + newHandB.z + " at " + Time.time);
}
}
handAPos = newHandA;
handBPos = newHandB;
}
private void StartDragging()
{
if (_isHolding)
{
return;
}
InputManager.Instance.PushModalInputHandler(sphere.gameObject);
_isHolding = true;
Vector3 gazeHitPosition = GazeManager.Instance.HitInfo.point;
Vector3 handPosition;
currentInputSource.TryGetPosition(currentInputSourceId, out handPosition);
prevHandPosX = handPosition.x;
prevHandPosY = handPosition.y;
}
public void StartDragging()
{
if (!gizmoSetting.IsDraggingEnabled)
{
return;
}
if (isDragging)
{
return;
}
InputManager.Instance.PushModalInputHandler(gameObject);
isDragging = true;
currentInputSource.TryGetPosition(currentInputSourceId, out startHandPosition);
Vector3 rotationAxisVec;
switch (rotationType)
{
case RotationType.Roll:
rotationAxisVec = gizmoSetting.HostTransform.right;
break;
case RotationType.Yaw:
rotationAxisVec = gizmoSetting.HostTransform.up;
break;
case RotationType.Pitch:
rotationAxisVec = gizmoSetting.HostTransform.forward;
break;
default:
return;
}
Vector3 projectionVect = Vector3.ProjectOnPlane(rotationAxisVec, mainCamera.transform.forward);
projectionVect.Normalize();
orthogonalRotationAxisVec = Vector3.Cross(mainCamera.transform.forward, projectionVect);
orthogonalRotationAxisVec.Normalize();
rend.material.color = gizmoSetting.rotDraggingColor;
gizmoSetting.IsDraggingRotator = true;
StartedDragging.RaiseEvent();
}
/// <summary>
/// Update the position of the object being dragged.
/// </summary>
private void UpdateDragging()
{
Vector3 newHandPosition;
currentInputSource.TryGetPosition(currentInputSourceId, out newHandPosition);
Vector3 pivotPosition = GetHandPivotPosition();
Vector3 newHandDirection = Vector3.Normalize(newHandPosition - pivotPosition);
newHandDirection = mainCamera.transform.InverseTransformDirection(newHandDirection); // in camera space
Vector3 targetDirection = Vector3.Normalize(gazeAngularOffset * newHandDirection);
targetDirection = mainCamera.transform.TransformDirection(targetDirection); // back to world space
float currenthandDistance = Vector3.Magnitude(newHandPosition - pivotPosition);
float distanceRatio = currenthandDistance / handRefDistance;
float distanceOffset = distanceRatio > 0 ? (distanceRatio - 1f) * DistanceScale : 0;
float targetDistance = objRefDistance + distanceOffset;
draggingPosition = pivotPosition + (targetDirection * targetDistance);
if (IsOrientTowardsUser)
{
draggingRotation = Quaternion.LookRotation(HostTransform.position - pivotPosition);
}
else
{
Vector3 objForward = mainCamera.transform.TransformDirection(objRefForward); // in world space
draggingRotation = Quaternion.LookRotation(objForward);
}
// Apply Final Position
HostTransform.position = draggingPosition + mainCamera.transform.TransformDirection(objRefGrabPoint);
HostTransform.rotation = draggingRotation;
if (IsKeepUpright)
{
Quaternion upRotation = Quaternion.FromToRotation(HostTransform.up, Vector3.up);
HostTransform.rotation = upRotation * HostTransform.rotation;
}
SV_ShareTransform();
}
// Update is called once per frame
// FixedUpdate is called in a regular timeline, same time between each call, to use for physics
void FixedUpdate()
{
// bit shift the index of the layer to get a bit mask
int layerMask = 1 << 8; // the layer 8 is the kern layer
RaycastHit gazeHitResult = GazeManager.Instance.HitInfo;
if (!isInputUp)
{
Debug.DrawLine(drawOriginPosition, drawOriginPosition + (replacedHandPosition - drawOriginPosition) * 2);
//get current inputsource Position information if we can
if (currentInputSource.SupportsInputInfo(currentInputSourceId, SupportedInputInfo.Position))
{
currentInputSource.TryGetPosition(currentInputSourceId, out handPosition);
//Debug.Log("Hand Position " + handPosition);
//replacing hand close to the user gaze direction to avoid occlusion issues
replacedHandPosition = handPosition + replacingHand;
//Raycast(originPoint, DIRECTION, etc.)
if (Physics.Raycast(drawOriginPosition, replacedHandPosition - drawOriginPosition, out hit, Mathf.Infinity, layerMask))
{
//drawingCursor show current drawing position and orientation
Vector3 lookForward = -GazeManager.Instance.GazeNormal; //Get the forward vector looking back at camera
drawingCursor.transform.position = hit.point + (lookForward * 0.02f);
drawingCursor.transform.rotation = Quaternion.LookRotation(Vector3.Lerp(gazeHitResult.normal, lookForward, 0.5f), Vector3.up);
drawingCursor.transform.Rotate(new Vector3(90.0f, 0.0f, 0.0f));
if (currentPoints.Count == 1)//first time in the loop
{
drawingCursor.SetActive(true);
mainCursor.SetVisiblity(false);
}
//to avoid a point repetitions
if (currentPoints.Count != 0 && currentPoints[currentPoints.Count - 1] != hit.point)
{
currentPoints.Add(hit.point + hit.normal * 0.0015f);
}
//drawing the line
if (currentPoints.Count != 0)
{
//setting the points of the line one by one
//using this instead of setPositions because it's more logical to use list here
currentLine.positionCount = currentPoints.Count;
for (int i = 0; i < currentPoints.Count; i++)
{
currentLine.SetPosition(i, currentPoints[i]);
}
}
}
else //no collision found between drawOriginPosition, handPosition and 3Dmodel
{
drawingCursor.transform.position = replacedHandPosition + Vector3.Normalize(replacedHandPosition - drawOriginPosition) * 1.5f;
}
}
}
}
/// <summary>
/// Starts dragging the object.
/// </summary>
public void StartDragging()
{
if (!IsDraggingAndScalingEnabled)
{
return;
}
if (isDragging)
{
return;
}
//extract the only input source
IInputSource currentInputSource = currentInputSources.Values.ToArray()[0];
uint currentInputSourceId = handsPositions.Keys.ToArray()[0];
// Add self as a modal input handler, to get all inputs during the manipulation
//InputManager.Instance.PushModalInputHandler(gameObject);
isDragging = true;
//GazeCursor.Instance.SetState(GazeCursor.State.Move);
//GazeCursor.Instance.SetTargetObject(HostTransform);
Vector3 gazeHitPosition = GazeManager.Instance.HitInfo.point;
Vector3 handPosition;
currentInputSource.TryGetPosition(currentInputSourceId, out handPosition);
Vector3 pivotPosition = GetHandPivotPosition();
handRefDistance = Vector3.Magnitude(handPosition - pivotPosition);
objRefDistance = Vector3.Magnitude(gazeHitPosition - pivotPosition);
Vector3 objForward = HostTransform.forward;
Vector3 objUp = HostTransform.up;
// Store where the object was grabbed from
objRefGrabPoint = mainCamera.transform.InverseTransformDirection(HostTransform.position - gazeHitPosition);
Vector3 objDirection = Vector3.Normalize(gazeHitPosition - pivotPosition);
Vector3 handDirection = Vector3.Normalize(handPosition - pivotPosition);
objForward = mainCamera.transform.InverseTransformDirection(objForward); // in camera space
objUp = mainCamera.transform.InverseTransformDirection(objUp); // in camera space
objDirection = mainCamera.transform.InverseTransformDirection(objDirection); // in camera space
handDirection = mainCamera.transform.InverseTransformDirection(handDirection); // in camera space
objRefForward = objForward;
objRefUp = objUp;
// Store the initial offset between the hand and the object, so that we can consider it when dragging
gazeAngularOffset = Quaternion.FromToRotation(handDirection, objDirection);
//draggingPosition = gazeHitPosition;
handsPositions[currentInputSourceId] = gazeHitPosition;
StartedDragging.RaiseEvent();
}
// Update is called once per frame
void Update()
{
if (isHolding)
{
currInputSource.TryGetPosition(currInputSourceId, out currHandPosition);
UpdateQuadVertices();
}
}
public void StartDragging()
{
if (!IsDraggingEnable)
{
return;
}
if (isDragging)
{
return;
}
InputManager.Instance.PushModalInputHandler(gameObject);
isDragging = true;
currentInputSource.TryGetPosition(currentInputSourceId, out startHandPosition);
Vector3 rotaitonAxisVect;
switch (axis)
{
case RotationAxis.x:
rotaitonAxisVect = target.transform.right;
break;
case RotationAxis.y:
rotaitonAxisVect = target.transform.up;
break;
case RotationAxis.z:
rotaitonAxisVect = target.transform.forward;
break;
default:
#if UNITY_EDITOR
Debug.LogError("Parameter 'axis' is not set.");
#endif
return;
}
Vector3 projectionVect = Vector3.ProjectOnPlane(rotaitonAxisVect, mainCamera.transform.forward);
projectionVect.Normalize();
orthogonalRotationAxisVect = Vector3.Cross(mainCamera.transform.forward, projectionVect);
orthogonalRotationAxisVect.Normalize();
}
private void StartDragging()
{
if (_isHolding) return;
InputManager.Instance.PushModalInputHandler(viewport.gameObject);
_isHolding = true;
Vector3 gazeHitPosition = GazeManager.Instance.HitInfo.point;
Vector3 handPosition;
currentInputSource.TryGetPosition(currentInputSourceId, out handPosition);
prevHandPosX = handPosition.x;
prevHandPosY = handPosition.y;
if (logging)
{
Debug.Log("Translate: Object Position " + viewport.gameObject.transform.position.x + "," +
viewport.gameObject.transform.position.y + viewport.gameObject.transform.position.z + " at " + Time.time);
Debug.Log("Translate: Hand: " + handPosition.x + "," + handPosition.y + "," + handPosition.z + " at " + Time.time);
}
}
