void IMixedRealityTouchHandler.OnTouchUpdated(HandTrackingInputEventData eventData)
{
if (targetObjectTransform != null)
{
targetObjectTransform.Rotate(Vector3.up * (rotateSpeed * Time.deltaTime));
}
}
/// <summary>
/// Handle the OnTouchCompleted event, changing the unfocused handle material.
/// </summary>
/// <param name="eventData">The event data.</param>
public void OnTouchCompleted(HandTrackingInputEventData eventData)
{
if (this.currentHandle == null && this.helpers.TryGetValue(eventData.CurrentTarget, out var handle))
{
this.ApplyMaterialToHandle(handle, h => h.IdleMaterial);
}
}
/// <summary>b
/// When the collider is touched, use the touch point to Calculate the Slider value
/// </summary>
public void OnTouchUpdated(HandTrackingInputEventData eventData)
{
if (isTouchable)
{
CalculateSliderValueBasedOnTouchPoint(eventData.InputData);
}
}
/// <inheritdoc/>
void IMixedRealityTouchHandler.OnTouchStarted(HandTrackingInputEventData eventData)
{
var cursor = eventData.Cursor;
// Start presses only once
if (this.cursorLocalPositions.ContainsKey(cursor))
{
return;
}
// Calculate cursor local transform
var localPosition = this.GetLocalPosition(eventData.Position);
// Calculate the press vector, obtained by keeping only the largest coordinate in the cursor local transform
var projectionX = new Vector3(localPosition.X, 0, 0);
var projectionY = new Vector3(0, localPosition.Y, 0);
var projectionZ = new Vector3(0, 0, localPosition.Z);
var projections = new Vector3[] { projectionX, projectionY, projectionZ };
var longestProjection = projections
.OrderByDescending(p => p.LengthSquared())
.First();
// Start touch if pressing from the set press direction or if the button can be pressed from every direction
if (!this.EnforceFrontPush || this.PressedFromPressDirection(longestProjection))
{
this.UpdateCursor(cursor, localPosition);
this.InternalOnTouchStarted(cursor);
}
}
void IMixedRealityTouchHandler.OnTouchStarted(HandTrackingInputEventData eventData)
{
touchPoints.Add(eventData.InputData);
if (initialTransform == null)
{
FindOrCreatePathMarkers();
// Make sure to initialize currentPushDistance now to correctly handle back-presses in
// HandlePressProgress().
currentPushDistance = GetFarthestPushDistanceAlongButtonAxis();
}
// Pulse each proximity light on pointer cursors's interacting with this button.
foreach (var pointer in eventData.InputSource.Pointers)
{
ProximityLight[] proximityLights = pointer.BaseCursor?.GameObjectReference?.GetComponentsInChildren <ProximityLight>();
if (proximityLights != null)
{
foreach (var proximityLight in proximityLights)
{
proximityLight.Pulse();
}
}
}
eventData.Use();
}
void IMixedRealityTouchHandler.OnTouchStarted(HandTrackingInputEventData eventData)
{
IInputHandler[] inputs = this.gameObject.GetComponents <IInputHandler>();
foreach (var input in inputs)
{
input.focusEnter();
}
}
void IMixedRealityTouchHandler.OnTouchUpdated(HandTrackingInputEventData eventData)
{
if (touchPoints.ContainsKey(eventData.Controller))
{
touchPoints[eventData.Controller] = eventData.InputData;
eventData.Use();
}
}
void IMixedRealityTouchHandler.OnTouchCompleted(HandTrackingInputEventData eventData)
{
if (touchPoints.ContainsKey(eventData.Controller))
{
touchPoints.Remove(eventData.Controller);
eventData.Use();
}
}
private void DoTouchCompleted(HandTrackingInputEventData eventData)
{
var cursor = eventData.Cursor;
if (this.cursorLocalPositions.ContainsKey(cursor))
{
this.TouchComplete(cursor);
}
}
/// <inheritdoc/>
public void OnTouchStarted(HandTrackingInputEventData eventData)
{
var transform = eventData.Cursor.Owner.FindComponent <Transform3D>();
this.touchInfos.Add(new TouchInfo {
Cursor = eventData.Cursor, Transform = transform, UV = this.GetUVPos(eventData.Position)
});
Tools.PlaySound(this.soundEmitter, this.PanStartedSound);
}
/// <inheritdoc/>
public void OnTouchStarted(HandTrackingInputEventData eventData)
{
if (eventData.Cursor.FindComponent <CursorRay>() == null)
{
this.touchInfos.Add(new TouchInfo {
Cursor = eventData.Cursor, Transform = eventData.Cursor.FindComponent <Transform3D>(), UV = GetUVPos(eventData.Position)
});
Tools.PlaySound(soundEmitter, PanStartedSound);
}
}
void IMixedRealityTouchHandler.OnTouchUpdated(HandTrackingInputEventData eventData)
{
OnTouchUpdated.Invoke(eventData);
if (debugTextTwo != null)
{
debugTextTwo.text = "OnTouchUpdated: " + Time.unscaledTime.ToString();
}
OnTouchUpdated.Invoke(eventData);
}
public void OnTouchCompleted(HandTrackingInputEventData eventData)
{
if (coolDownRemaining <= 0)
{
Debug.Log("TOUCHED");
Debug.Log(gameObject.name);
pointSelector.ShowToolTip(gameObject);
pointSelector.LightUpBalls(gameObject.name);
coolDownRemaining = Cooldown;
}
}
/// <inheritdoc/>
void IMixedRealityTouchHandler.OnTouchUpdated(HandTrackingInputEventData eventData)
{
this.touchUpdatedRan = true;
var cursor = eventData.Cursor;
if (this.cursorLocalPositions.ContainsKey(cursor))
{
this.DoTouchUpdated(eventData);
}
}
public void OnTouchStarted(HandTrackingInputEventData eventData)
{
if (isTouchable)
{
if (OnInteractionStarted != null)
{
OnInteractionStarted.Invoke(new SliderEventData(sliderValue, sliderValue, ActivePointer, this));
}
eventData.Use();
}
}
private void RunTouchHandlers(Entity other, Action <IMixedRealityTouchHandler, HandTrackingInputEventData> action)
{
var eventArgs = new HandTrackingInputEventData()
{
Cursor = this,
Position = this.transform.Position,
PreviousPosition = this.PositionHistory.Count() > 1 ? this.PositionHistory[this.PositionHistory.Count - 2] : Vector3.Zero,
CurrentTarget = other,
};
other.RunOnComponents <IMixedRealityTouchHandler>((x) => action(x, eventArgs));
}
/// <inheritdoc/>
void IMixedRealityTouchHandler.OnTouchCompleted(HandTrackingInputEventData eventData)
{
var cursor = eventData.Cursor;
if (this.cursorLocalPositions.ContainsKey(cursor))
{
this.InternalOnTouchCompleted(cursor);
this.cursorLocalPositions.Remove(cursor);
this.cursorDistances.Remove(cursor);
}
}
/// <inheritdoc/>
void IMixedRealityTouchHandler.OnTouchUpdated(HandTrackingInputEventData eventData)
{
var cursor = eventData.Cursor;
if (this.cursorLocalPositions.ContainsKey(cursor))
{
var localPosition = this.GetLocalPosition(eventData.Position);
this.UpdateCursor(cursor, localPosition);
this.InternalOnTouchUpdated(cursor);
}
}
void IMixedRealityTouchHandler.OnTouchCompleted(HandTrackingInputEventData eventData)
{
IInputHandler[] inputs = this.gameObject.GetComponents <IInputHandler>();
foreach (var input in inputs)
{
input.focusExit();
}
IClicker[] clickers = this.gameObject.GetComponents <IClicker>();
foreach (var click in clickers)
{
click.execute();
}
}
public void OnTouchCompleted(HandTrackingInputEventData eventData)
{
if (isTouchable)
{
if (!eventData.used)
{
EndInteraction();
// Mark the pointer data as used to prevent other behaviors from handling input events
eventData.Use();
}
}
}
void IMixedRealityTouchHandler.OnTouchCompleted(HandTrackingInputEventData eventData)
{
OnTouchCompleted.Invoke(eventData);
if (debugMessage != null)
{
debugMessage.text = "OnTouchCompleted: " + Time.unscaledTime.ToString();
}
if ((TargetRenderer != null) && (TargetRenderer.material != null))
{
TargetRenderer.material.color = originalColor;
}
}
void IMixedRealityTouchHandler.OnTouchStarted(HandTrackingInputEventData eventData)
{
OnTouchStarted.Invoke(eventData);
if (debugMessage != null)
{
debugMessage.text = "OnTouchStarted: " + Time.unscaledTime.ToString();
}
if (TargetRenderer != null)
{
TargetRenderer.sharedMaterial.color = Color.Lerp(originalColor, highlightedColor, 2.0f);
}
}
/// <inheritdoc/>
public void OnTouchCompleted(HandTrackingInputEventData eventData)
{
for (int i = 0; i < touchInfos.Count; ++i)
{
if (this.touchInfos[i].Cursor == eventData.Cursor)
{
this.touchInfos.RemoveAt(i);
break;
}
}
RemapTouches();
Tools.PlaySound(soundEmitter, PanEndedSound);
}
void IMixedRealityTouchHandler.OnTouchUpdated(HandTrackingInputEventData eventData)
{
OnTouchUpdated.Invoke(eventData);
if (debugMessage2 != null)
{
debugMessage2.text = "OnTouchUpdated: " + Time.unscaledTime.ToString();
}
if ((TargetRenderer != null) && (TargetRenderer.material != null))
{
TargetRenderer.material.color = Color.Lerp(Color.green, Color.red, t);
t = Mathf.PingPong(Time.time, duration) / duration;
}
}
public void OnTouchStarted(HandTrackingInputEventData eventData)
{
if (this.soundEmitter != null)
{
if (this.soundEmitter.PlayState == PlayState.Playing)
{
this.soundEmitter.Stop();
}
this.soundEmitter.Audio = sound;
this.soundEmitter.Play();
}
rotate.Lock();
}
public void OnTouchStarted(HandTrackingInputEventData eventData)
{
animating = true;
animation_time = 0.0f;
cachedColor = materialDecorator.Parameters_Color;
if (this.soundEmitter != null)
{
if (this.soundEmitter.PlayState == PlayState.Playing)
{
this.soundEmitter.Stop();
}
this.soundEmitter.Audio = sound;
this.soundEmitter.Play();
}
}
/// <inheritdoc/>
void IMixedRealityTouchHandler.OnTouchCompleted(HandTrackingInputEventData eventData)
{
var cursor = eventData.Cursor;
if (this.cursorLocalPositions.ContainsKey(cursor))
{
if (!this.touchUpdatedRan)
{
// Delay TouchCompleted for one frame to allow for events to fire.
this.DoTouchUpdated(eventData);
this.forceRunTouchCompletedEventData = eventData;
}
else
{
this.DoTouchCompleted(eventData);
}
}
}
private void RunTouchHandlers(Entity cursor, Entity other, Action <IMixedRealityTouchHandler, HandTrackingInputEventData> action)
{
var position = cursor.FindComponent <Transform3D>().Position;
var eventArgs = new HandTrackingInputEventData()
{
Cursor = cursor,
Position = position,
};
var interactables = this.GatherComponents(other)
.Where(x => x.IsActivated)
.OfType <IMixedRealityTouchHandler>();
foreach (var touchHandler in interactables)
{
action(touchHandler, eventArgs);
}
}
/// <inheritdoc/>
protected override void Update(TimeSpan gameTime)
{
if (this.forceRunTouchCompletedEventData != null)
{
if (this.delayedFrames++ == 2)
{
this.DoTouchCompleted(this.forceRunTouchCompletedEventData);
this.forceRunTouchCompletedEventData = null;
this.delayedFrames = 0;
}
}
switch (this.simulatePressState)
{
default:
return;
case PressSimulationState.Pressing:
this.simulatedPressAmount += (float)(gameTime.TotalSeconds / this.SimulatedPressDuration.TotalSeconds);
break;
case PressSimulationState.Releasing:
this.simulatedPressAmount -= (float)(gameTime.TotalSeconds / this.SimulatedPressDuration.TotalSeconds);
break;
}
this.simulatedPressAmount = MathHelper.Clamp(this.simulatedPressAmount, 0, 1);
var cursor = this.simulatedPointerEventData.Cursor;
if (this.simulatedPressAmount > 0)
{
var localPressPosition = this.GetSimulatedPressStepPosition(this.simulatedPointerEventData.Position, this.simulatedPressAmount);
this.TouchUpdate(cursor, localPressPosition);
}
else
{
this.simulatedPointerEventData = null;
this.simulatePressState = PressSimulationState.None;
this.TouchComplete(cursor);
}
}
public void OnTouchStarted(HandTrackingInputEventData eventData)
{
_panningPointer = PointerUtils.GetPointer <PokePointer>(eventData.Handedness);
if (CoreServices.InputSystem.FocusProvider.TryGetFocusDetails(_panningPointer, out FocusDetails focusDetails) &&
focusDetails.Object == gameObject)
{
//_panningPointer = eventData.Pointer;
_startingPointInLocalSpace = focusDetails.PointLocalSpace;
_startingPointInMercatorSpace =
_mapRenderer.TransformLocalPointToMercatorWithAltitude(
_startingPointInLocalSpace,
out _startingAltitudeInMeters,
out _startingMercatorScale);
_currentPointInLocalSpace = _startingPointInLocalSpace;
_startingMapCenterInMercator = _mapRenderer.Center.ToMercatorPosition();
eventData.Use();
}
}