protected virtual void OnDragging(BaseHandle handle, HandleEventData eventData)
{
if (singleClickDrag)
{
if (m_DragObject)
{
var previewOrigin = getPreviewOriginForRayOrigin(eventData.rayOrigin);
MathUtilsExt.LerpTransform(m_DragObject, previewOrigin.position, previewOrigin.rotation, m_DragLerp);
}
}
else
{
// Only allow direct grabbing
if (!m_DirectGrab)
{
return;
}
var rayOrigin = eventData.rayOrigin;
var dragStart = m_DragStarts[rayOrigin];
var dragVector = rayOrigin.position - dragStart;
var distance = dragVector.magnitude;
if (m_DragObject == null && distance > k_DragDeadzone * getViewerScale())
{
m_DragObject = handle.transform;
OnGrabDragStart(handle, eventData, dragStart);
}
if (m_DragObject)
{
OnGrabDragging(handle, eventData, dragStart);
}
}
}
protected override void OnDragging(BaseHandle baseHandle, HandleEventData eventData)
{
if (m_ClickedField)
{
var rayOrigin = eventData.rayOrigin;
m_DragDistance = (rayOrigin.position - m_DragStarts[rayOrigin]).magnitude;
var numericField = m_ClickedField as NumericInputField;
if (numericField)
{
if (m_DragDistance > NumericInputField.DragDeadzone)
{
CancelSingleClick();
}
numericField.SliderDrag(eventData.rayOrigin);
}
}
if (m_DragObject)
{
var previewOrigin = getPreviewOriginForRayOrigin(eventData.rayOrigin);
MathUtilsExt.LerpTransform(m_DragObject, previewOrigin.position,
MathUtilsExt.ConstrainYawRotation(CameraUtils.GetMainCamera().transform.rotation), m_DragLerp);
}
}
void MagnetizeTransform(Transform fieldGrabOrigin, Transform transform, float stackingOffset = 0)
{
var rotation = CameraUtils.GetMainCamera().transform.rotation.ConstrainYaw() * Quaternion.AngleAxis(90, Vector3.left);
var stackingDirection = rotation * Vector3.one;
MathUtilsExt.LerpTransform(transform, fieldGrabOrigin.position - stackingDirection * stackingOffset, rotation, m_DragLerp);
}
protected virtual void OnDragging(BaseHandle baseHandle, HandleEventData eventData)
{
if (m_DragObject)
{
var previewOrigin = getPreviewOriginForRayOrigin(eventData.rayOrigin);
MathUtilsExt.LerpTransform(m_DragObject, previewOrigin.position, previewOrigin.rotation, m_DragLerp);
}
}
protected virtual void OnVerticalDragging(Transform rayOrigin)
{
if (m_DragClone)
{
var fieldGrabOrigin = this.GetFieldGrabOriginForRayOrigin(rayOrigin);
var rotation = MathUtilsExt.ConstrainYawRotation(CameraUtils.GetMainCamera().transform.rotation);
MathUtilsExt.LerpTransform(m_DragClone, fieldGrabOrigin.position, rotation, m_DragLerp);
}
}
internal void UpdateMiniWorlds(ConsumeControlDelegate consumeControl)
{
if (m_MiniWorldIgnoreListDirty)
{
UpdateMiniWorldIgnoreList();
m_MiniWorldIgnoreListDirty = false;
}
var objectsGrabber = evr.m_DirectSelection.objectsGrabber;
foreach (var kvp in m_MiniWorldInputs)
{
kvp.Key.ProcessInput(kvp.Value, consumeControl);
}
// Update MiniWorldRays
foreach (var ray in m_Rays)
{
var miniWorldRayOrigin = ray.Key;
var miniWorldRay = ray.Value;
if (!miniWorldRay.proxy.active)
{
miniWorldRay.tester.active = false;
continue;
}
var miniWorld = miniWorldRay.miniWorld;
var inverseScale = miniWorld.miniWorldTransform.lossyScale.Inverse();
if (float.IsInfinity(inverseScale.x) || float.IsNaN(inverseScale.x)) // Extreme scales cause transform errors
{
continue;
}
// Transform into reference space
var originalRayOrigin = miniWorldRay.originalRayOrigin;
var referenceTransform = miniWorld.referenceTransform;
miniWorldRayOrigin.position = referenceTransform.position + Vector3.Scale(miniWorld.miniWorldTransform.InverseTransformPoint(originalRayOrigin.position), miniWorld.referenceTransform.localScale);
miniWorldRayOrigin.rotation = referenceTransform.rotation * Quaternion.Inverse(miniWorld.miniWorldTransform.rotation) * originalRayOrigin.rotation;
miniWorldRayOrigin.localScale = Vector3.Scale(inverseScale, referenceTransform.localScale);
var directSelection = evr.m_DirectSelection;
// Set miniWorldRayOrigin active state based on whether controller is inside corresponding MiniWorld
var originalPointerPosition = originalRayOrigin.position + originalRayOrigin.forward * directSelection.GetPointerLength(originalRayOrigin);
var isContained = miniWorld.Contains(originalPointerPosition);
miniWorldRay.tester.active = isContained;
miniWorldRayOrigin.gameObject.SetActive(isContained);
var directSelectInput = (DirectSelectInput)miniWorldRay.directSelectInput;
var dragObjects = miniWorldRay.dragObjects;
if (dragObjects == null)
{
var heldObjects = objectsGrabber.GetHeldObjects(miniWorldRayOrigin);
if (heldObjects != null)
{
// Only one ray can grab an object, otherwise PlaceObject is called on each trigger release
// This does not prevent TransformTool from doing two-handed scaling
var otherRayHasObject = false;
foreach (var otherRay in m_Rays.Values)
{
if (otherRay != miniWorldRay && otherRay.dragObjects != null)
{
otherRayHasObject = true;
}
}
if (!otherRayHasObject)
{
miniWorldRay.dragObjects = heldObjects;
var scales = new Vector3[heldObjects.Length];
var dragGameObjects = new GameObject[heldObjects.Length];
for (var i = 0; i < heldObjects.Length; i++)
{
var dragObject = heldObjects[i];
scales[i] = dragObject.transform.localScale;
dragGameObjects[i] = dragObject.gameObject;
}
var totalBounds = ObjectUtils.GetBounds(dragGameObjects);
var maxSizeComponent = totalBounds.size.MaxComponent();
if (!Mathf.Approximately(maxSizeComponent, 0f))
{
miniWorldRay.previewScaleFactor = Vector3.one * (k_PreviewScale * Viewer.GetViewerScale() / maxSizeComponent);
}
miniWorldRay.originalScales = scales;
}
}
}
// Transfer objects to and from original ray and MiniWorld ray (e.g. outside to inside mini world)
if (directSelection != null && isContained != miniWorldRay.wasContained)
{
var pointerLengthDiff = directSelection.GetPointerLength(miniWorldRayOrigin) - directSelection.GetPointerLength(originalRayOrigin);
var from = isContained ? originalRayOrigin : miniWorldRayOrigin;
var to = isContained ? miniWorldRayOrigin : originalRayOrigin;
if (isContained || miniWorldRay.dragObjects == null)
{
objectsGrabber.TransferHeldObjects(from, to, pointerLengthDiff * Vector3.forward);
}
}
// Transfer objects between MiniWorlds
if (dragObjects == null)
{
if (isContained)
{
foreach (var kvp in m_Rays)
{
var otherRayOrigin = kvp.Key;
var otherRay = kvp.Value;
var otherObjects = otherRay.dragObjects;
if (otherRay != miniWorldRay && !otherRay.wasContained && otherObjects != null)
{
dragObjects = otherObjects;
miniWorldRay.dragObjects = otherObjects;
miniWorldRay.originalScales = otherRay.originalScales;
miniWorldRay.previewScaleFactor = otherRay.previewScaleFactor;
otherRay.dragObjects = null;
if (directSelection != null)
{
var heldObjects = objectsGrabber.GetHeldObjects(otherRayOrigin);
if (heldObjects != null)
{
objectsGrabber.TransferHeldObjects(otherRayOrigin, miniWorldRayOrigin,
Vector3.zero); // Set the new offset to zero because the object will have moved (this could be improved by taking original offset into account)
}
}
break;
}
}
}
}
if (isContained && !miniWorldRay.wasContained)
{
Rays.HideRay(originalRayOrigin, true);
Rays.LockRay(originalRayOrigin, this);
}
if (!isContained && miniWorldRay.wasContained)
{
Rays.UnlockRay(originalRayOrigin, this);
Rays.ShowRay(originalRayOrigin, true);
}
if (dragObjects == null)
{
miniWorldRay.wasContained = isContained;
continue;
}
var previewScaleFactor = miniWorldRay.previewScaleFactor;
var positionOffsets = miniWorldRay.originalPositionOffsets;
var rotationOffsets = miniWorldRay.originalRotationOffsets;
var originalScales = miniWorldRay.originalScales;
if (directSelectInput.select.isHeld)
{
if (isContained)
{
// Scale the object back to its original scale when it re-enters the MiniWorld
if (!miniWorldRay.wasContained)
{
for (var i = 0; i < dragObjects.Length; i++)
{
var dragObject = dragObjects[i];
dragObject.localScale = originalScales[i];
MathUtilsExt.SetTransformOffset(miniWorldRayOrigin, dragObject, positionOffsets[i], rotationOffsets[i]);
}
// Add the object (back) to TransformTool
if (directSelection != null)
{
objectsGrabber.GrabObjects(miniWorldRay.node, miniWorldRayOrigin, directSelectInput, dragObjects);
}
}
}
else
{
// Check for player head
for (var i = 0; i < dragObjects.Length; i++)
{
var dragObject = dragObjects[i];
if (dragObject.CompareTag(k_VRPlayerTag))
{
if (directSelection != null)
{
objectsGrabber.DropHeldObjects(miniWorldRayOrigin);
}
// Drop player at edge of MiniWorld
miniWorldRay.dragObjects = null;
dragObjects = null;
break;
}
}
if (dragObjects == null)
{
continue;
}
if (miniWorldRay.wasContained)
{
var containedInOtherMiniWorld = false;
foreach (var world in m_Worlds)
{
if (miniWorld != world && world.Contains(originalPointerPosition))
{
containedInOtherMiniWorld = true;
}
}
// Don't switch to previewing the objects we are dragging if we are still in another mini world
if (!containedInOtherMiniWorld)
{
for (var i = 0; i < dragObjects.Length; i++)
{
var dragObject = dragObjects[i];
// Store the original scale in case the object re-enters the MiniWorld
originalScales[i] = dragObject.localScale;
dragObject.localScale = Vector3.Scale(dragObject.localScale, previewScaleFactor);
}
// Drop from TransformTool to take control of object
if (directSelection != null)
{
objectsGrabber.DropHeldObjects(miniWorldRayOrigin, out positionOffsets, out rotationOffsets);
miniWorldRay.originalPositionOffsets = positionOffsets;
miniWorldRay.originalRotationOffsets = rotationOffsets;
miniWorldRay.wasHeld = true;
}
}
}
for (var i = 0; i < dragObjects.Length; i++)
{
var dragObject = dragObjects[i];
var rotation = originalRayOrigin.rotation;
var position = originalRayOrigin.position
+ rotation * Vector3.Scale(previewScaleFactor, positionOffsets[i]);
MathUtilsExt.LerpTransform(dragObject, position, rotation * rotationOffsets[i]);
}
}
}
// Release the current object if the trigger is no longer held
if (directSelectInput.select.wasJustReleased)
{
var rayPosition = originalRayOrigin.position;
for (var i = 0; i < dragObjects.Length; i++)
{
var dragObject = dragObjects[i];
// If the user has pulled an object out of the MiniWorld, use PlaceObject to grow it back to its original scale
if (!isContained)
{
if (evr.m_Viewer.IsOverShoulder(originalRayOrigin))
{
evr.m_SceneObjectModule.DeleteSceneObject(dragObject.gameObject);
}
else
{
dragObject.localScale = originalScales[i];
var rotation = originalRayOrigin.rotation;
dragObject.position = rayPosition + rotation * positionOffsets[i];
dragObject.rotation = rotation * rotationOffsets[i];
}
}
}
miniWorldRay.dragObjects = null;
miniWorldRay.wasHeld = false;
}
miniWorldRay.wasContained = isContained;
}
}
