public void PreventRightTap()
{
_settings &= ~GestureSettings.RightTap;
if ((_settings & GestureSettingsHelper.SupportedGestures) == GestureSettings.None)
{
IsCompleted = true;
}
}
/// <summary>
/// <para>Set the recognizable gestures to the ones specified in newMaskValues and return the old settings.</para>
/// </summary>
/// <param name="newMaskValue">A mask indicating which gestures are now recognizable.</param>
/// <returns>
/// <para>The previous value.</para>
/// </returns>
public GestureSettings SetRecognizableGestures(GestureSettings newMaskValue)
{
if (this.m_Recognizer != IntPtr.Zero)
{
return((GestureSettings)this.Internal_SetRecognizableGestures(this.m_Recognizer, (int)newMaskValue));
}
return(GestureSettings.None);
}
public void PreventHolding()
{
StopHoldingTimer();
_settings &= ~(GestureSettings.Hold | GestureSettings.HoldWithMouse);
if ((_settings & GestureSettingsHelper.SupportedGestures) == GestureSettings.None)
{
IsCompleted = true;
}
}
public TouchGesture(GestureSettings gestureSettings = null)
{
if (gestureSettings != null)
{
settings = gestureSettings;
}
else
{
settings = new GestureSettings();
}
}
public InputHandler(TrackerConfig tracker, TrackerHandedness handedness)
{
_tracker = tracker;
_handedness = handedness;
#if UNITY_WSA
_gestureRecognizer = new GestureRecognizer();
GestureSettings gestureMask = GetGestureMask(tracker);
// Using gestures
if (gestureMask != GestureSettings.None)
{
// Add tap to recognisor
if (gestureMask.HasFlag(GestureSettings.Tap) || gestureMask.HasFlag(GestureSettings.DoubleTap))
{
_gestureRecognizer.Tapped += GestureTapped;
}
// Add hold to recognisor
if (gestureMask.HasFlag(GestureSettings.Hold))
{
_gestureRecognizer.HoldStarted += GestureHoldStarted;
_gestureRecognizer.HoldCompleted += GestureHoldCompleted;
_gestureRecognizer.HoldCanceled += GestureHoldCanceled;
}
// Add manipulation to recognisor
if (gestureMask.HasFlag(GestureSettings.ManipulationTranslate))
{
_gestureRecognizer.ManipulationStarted += GestureManipulationStarted;
_gestureRecognizer.ManipulationCompleted += GestureManipulationCompleted;
_gestureRecognizer.ManipulationCanceled += GestureManipulationCanceled;
_gestureRecognizer.ManipulationUpdated += GestureManipulationUpdated;;
}
// Add navigation to recognisor
if (gestureMask.HasFlag(GestureSettings.NavigationX) || gestureMask.HasFlag(GestureSettings.NavigationY) ||
gestureMask.HasFlag(GestureSettings.NavigationZ))
{
_gestureRecognizer.NavigationStarted += GestureNavigationStarted;
_gestureRecognizer.NavigationCompleted += GestureNavigationCompleted;
_gestureRecognizer.NavigationCanceled += GestureNavigationCanceled;
_gestureRecognizer.NavigationUpdated += GestureNavigationUpdated;;
}
_gestureRecognizer.SetRecognizableGestures(gestureMask);
_gestureRecognizer.StartCapturingGestures();
}
#endif
// Using speech recognition
_speechRecognizer = new DictationRecognizer();
_speechRecognizer.DictationResult += SpeechRecognition;
}
void Start()
{
m_AudioButtonPress = FindObjectOfType <AudioSource>();
// Set up a GestureRecognizer to detect Select gestures.
m_GestureRecognizer = new GestureRecognizer();
GestureSettings m_GestureSettings = m_GestureRecognizer.GetRecognizableGestures();
m_GestureSettings |= GestureSettings.DoubleTap;
m_GestureRecognizer.SetRecognizableGestures(m_GestureSettings);
SetupGestureEvents();
m_GestureRecognizer.StartCapturingGestures();
}
public GestureSettings SetRecognizableGestures(GestureSettings newMaskValue)
{
GestureSettings result;
if (this.m_Recognizer != IntPtr.Zero)
{
result = (GestureSettings)this.Internal_SetRecognizableGestures(this.m_Recognizer, (int)newMaskValue);
}
else
{
result = GestureSettings.None;
}
return(result);
}
void Start()
{
m_AudioButtonPress = FindObjectOfType <AudioSource>();
m_GestureRecognizer = new GestureRecognizer();
GestureSettings m_GestureSettings = m_GestureRecognizer.GetRecognizableGestures();
m_GestureSettings |= GestureSettings.DoubleTap;
m_GestureRecognizer.SetRecognizableGestures(m_GestureSettings);
SetupGestureEvents();
m_GestureRecognizer.StartCapturingGestures();
if (!m_DisplayOnLoad)
{
gameObject.SetActive(false);
}
}
// Get the gesture mask for a tracker
private GestureSettings GetGestureMask(TrackerConfig tracker)
{
GestureSettings gestureMask = GestureSettings.None;
// Check for gestures
foreach (var axis in tracker.json["buttons"].Children)
{
switch (axis["id"])
{
case "tap":
gestureMask |= GestureSettings.Tap;
break;
case "double_tap":
gestureMask |= GestureSettings.DoubleTap;
break;
case "hold":
gestureMask |= GestureSettings.Hold;
break;
case "manipulation_x":
case "manipulation_y":
case "manipulation_z":
gestureMask |= GestureSettings.ManipulationTranslate;
break;
case "navigation_x":
gestureMask |= GestureSettings.NavigationX;
break;
case "navigation_y":
gestureMask |= GestureSettings.NavigationY;
break;
case "navigation_z":
gestureMask |= GestureSettings.NavigationZ;
break;
}
}
return(gestureMask);
}
public void ChangeAcceptedGestures(GestureSettings[] gestures)
{
GestureSettings mask = new GestureSettings();
gestureRecognizer.StopCapturingGestures();
if (gestures != null)
{
foreach (GestureSettings g in gestures)
{
mask |= g;
}
gestureRecognizer.SetRecognizableGestures(mask);
}
else
{
gestureRecognizer.SetRecognizableGestures(GestureSettings.None);
}
gestureRecognizer.StartCapturingGestures();
}
public Gesture(GestureRecognizer recognizer, PointerPoint down)
{
_recognizer = recognizer;
_settings = recognizer._gestureSettings & GestureSettingsHelper.SupportedGestures; // Keep only flags of supported gestures, so we can more quickly disable us if possible
_settings |= GestureSettings.Tap; // On WinUI, Tap is always raised no matter the flag set on the recognizer
Down = down;
PointerIdentifier = GetPointerIdentifier(down);
PointerType = (PointerDeviceType)down.PointerDevice.PointerDeviceType;
// This is how WinUI behaves: it will fire the double tap
// on Down for a double tap instead of the Up.
if (TryRecognizeMultiTap())
{
IsCompleted = true;
}
else if (SupportsHolding())
{
StartHoldingTimer();
}
}
// Be aware that this class is not part of the UWP contract
internal ManipulationStartingEventArgs(PointerIdentifier pointer, GestureSettings settings)
{
Pointer = pointer;
Settings = settings;
}
/// <summary>
/// <para>Set the recognizable gestures to the ones specified in newMaskValues and return the old settings.</para>
/// </summary>
/// <param name="newMaskValue">A mask indicating which gestures are now recognizable.</param>
/// <returns>
/// <para>The previous value.</para>
/// </returns>
public GestureSettings SetRecognizableGestures(GestureSettings newMaskValue)
{
if (this.m_Recognizer != IntPtr.Zero)
{
return (GestureSettings) this.Internal_SetRecognizableGestures(this.m_Recognizer, (int) newMaskValue);
}
return GestureSettings.None;
}
public GestureRecognizerBase(GestureSettings settings)
{
Recognizer = new GestureRecognizer();
Recognizer.SetRecognizableGestures(settings);
}
public TouchGesture(GestureSettings gestureSettings)
{
this.settings = gestureSettings;
}
public TouchGesture(GestureSettings gestureSettings)
{
this.settings = gestureSettings;
this.speed = GameObject.Find("Clickmesh").GetComponent <Speed> ();
}
/// <summary>
/// Sets the current recognizable gestures to the specified set. Returns
/// the previous value.
public GestureSettings SetRecognizableGestures(GestureSettings newMaskValue)
{
return((GestureSettings)SetRecognizableGestures_Internal((int)newMaskValue));
}
/// <summary>
/// Sets the current recognizable gestures to the specified set. Returns
/// the previous value.
public GestureSettings SetRecognizableGestures(GestureSettings newMaskValue)
{
return(GestureSettings.None);
}
public void Enable()
{
Disable();
#if UNITY_WSA
// Is the holoLens
if (display != null)
{
CreateTransmitter();
// Add gesture recogniser if needed
HoloLensData holoLens = display.HoloLensData();
if (holoLens != null && holoLens.axesGestures.Count > 0)
{
recognizer = new GestureRecognizer();
// The types of gestures to listen for
GestureSettings gestureMask = GestureSettings.None;
foreach (var gesture in holoLens.buttonGestures)
{
switch (gesture.type)
{
case HoloLensData.ButtonGesture.Type.TAP:
gestureMask |= GestureSettings.Tap;
break;
case HoloLensData.ButtonGesture.Type.DOUBLE_TAP:
gestureMask |= GestureSettings.DoubleTap;
break;
case HoloLensData.ButtonGesture.Type.HOLD:
gestureMask |= GestureSettings.Hold;
recognizer.HoldStarted += GestureHoldStarted;
recognizer.HoldCompleted += GestureHoldCompleted;
recognizer.HoldCanceled += GestureHoldCanceled;
break;
}
}
if (gestureMask.HasFlag(GestureSettings.Tap) || gestureMask.HasFlag(GestureSettings.DoubleTap))
recognizer.Tapped += GestureTapped;
foreach (var gesture in holoLens.axesGestures)
{
switch (gesture.type)
{
case HoloLensData.AxesGesture.Type.MANIPULATION:
gestureMask |= GestureSettings.ManipulationTranslate;
recognizer.ManipulationStarted += GestureManipulationStarted;
recognizer.ManipulationCompleted += GestureManipulationCompleted;
recognizer.ManipulationCanceled += GestureManipulationCanceled;
recognizer.ManipulationUpdated += GestureManipulationUpdated; ;
break;
case HoloLensData.AxesGesture.Type.NAVIGATION:
if (gesture.mappingsX.Count != 0) { gestureMask |= GestureSettings.NavigationX; }
if (gesture.mappingsX.Count != 0) { gestureMask |= GestureSettings.NavigationY; }
if (gesture.mappingsX.Count != 0) { gestureMask |= GestureSettings.NavigationZ; }
recognizer.NavigationStarted += GestureNavigationStarted;
recognizer.NavigationCompleted += GestureNavigationCompleted;
recognizer.NavigationCanceled += GestureNavigationCanceled;
recognizer.NavigationUpdated += GestureNavigationUpdated; ;
break;
}
}
// Start the recogniser
recognizer.SetRecognizableGestures(gestureMask);
recognizer.StartCapturingGestures();
}
SetUpHoloLens();
}
#endif
}
public TouchGesture(GestureSettings gestureSettings)
{
this.settings = gestureSettings;
}
public GestureSettings SetRecognizableGestures(GestureSettings newMaskValue)
{
return(new GestureSettings());
}
// Be aware that this class is not part of the UWP contract
internal ManipulationStartingEventArgs(GestureSettings settings)
{
Settings = settings;
}
/// <summary>
/// Initializes a new instance of the <see cref="ManipulationInputProcessor" /> class.
/// </summary>
/// <param name="target">The target element.</param>
/// <param name="referenceFrame">The element that will be used as a reference frame.</param>
/// <param name="gestureSettings">The gesture recognizer settings.</param>
public ManipulationInputProcessor(FrameworkElement target, FrameworkElement referenceFrame, GestureSettings gestureSettings)
{
this.gestureRecognizer = new GestureRecognizer {
GestureSettings = gestureSettings
};
this.element = target;
this.reference = referenceFrame;
// Set up pointer event handlers. These receive input events that are used by the gesture recognizer.
this.reference.PointerCanceled += this.OnPointerCanceled;
this.reference.PointerPressed += this.OnPointerPressed;
this.reference.PointerReleased += this.OnPointerReleased;
this.reference.PointerMoved += this.OnPointerMoved;
this.reference.DoubleTapped += this.OnDoubleTapped;
// Set up event handlers to respond to gesture recognizer output
////this.gestureRecognizer.Tapped += this.OnTapped;
////this.gestureRecognizer.RightTapped += this.OnRightTapped;
////this.gestureRecognizer.ManipulationStarted += this.OnManipulationStarted;
////this.gestureRecognizer.ManipulationCompleted += this.OnManipulationCompleted;
this.gestureRecognizer.ManipulationUpdated += this.OnManipulationUpdated;
}
