/// <summary>
/// Coroutine that trigger Hold Event when one finger holded
/// after given HoldDuration time in second
/// </summary>
/// <param name="position"></param>
/// <returns></returns>
private IEnumerator FingerHold(Vector2 position)
{
yield return(new WaitForSeconds(holdDuration));
GestureType = GestureTypes.Hold;
OnHold?.Invoke(position);
}
public virtual bool ReceiveEvent(GestureTypes type)
{
Debug.Log("ReceiveEvent " + type.ToString());
_currentType = type;
Invoke("unBlockCurrentGesture", TimeBetween2Gestures);
return(true);
}
/// <summary>
/// Resets all of touch processes
/// </summary>
private void Reset()
{
raycastResult.Clear();
startPositions = new Vector2[2];
endPositions = new Vector2[2];
GestureType = GestureTypes.Touch;
}
public override void LoadingGestureProgress(GestureTypes type, float percent)
{
if (_gameManager != null)
{
_gameManager.UpdateUILoadingGesture(type, percent);
}
}
public void OnGesture(GestureTypes gestureType,
GameObject focusedGameObject)
{
AudioClip audioClip = null;
GestureSoundHandler gestureSoundHandler = null;
if (focusedGameObject != null)
{
gestureSoundHandler = focusedGameObject.GetComponent <GestureSoundHandler>();
}
if (gestureSoundHandler != null)
{
// Fetch the appropriate audio clip from the GestureSoundHandler's AudioClips array.
audioClip = gestureSoundHandler.AudioClips[(int)gestureType];
}
if (audioClip != null)
{
// Move the audio source container to the location of the focused object so that
// the gesture sound is properly spatialized with the focused object.
audioSourceContainer.transform.position = focusedGameObject.transform.position;
// Set the AudioSource clip field to the audioClip
audioSource.clip = audioClip;
// Play the AudioSource
audioSource.Play();
}
else
{
// Stop the AudioSource
audioSource.Stop();
}
}
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="e">Gesture event arguments.</param>
private void OnGestureRecognized(object sender, GestureEventArgs e)
{
switch (e.GestureName)
{
case "JoinedHands":
//KinectSwipeDetected = GestureTypes.JoinedHands;
break;
case "SwipeLeft":
KinectGestureDetected = GestureTypes.RightSwipe;
break;
case "SwipeRight":
KinectGestureDetected = GestureTypes.LeftSwipe;
break;
case "SwipeUp":
//KinectSwipeDetected = GestureTypes.SwipeUp;
break;
default:
break;
}
_clearTimer.Start();
}
/// <summary>
/// Sets whether a gesture should be handled by the touchpad.
/// </summary>
/// <param name="gestureTypes">The gesture type to set.</param>
/// <param name="enabled">True to enable gesture, false to disable.</param>
public void SetGesture(GestureTypes gestureTypes, bool enabled)
{
_log.DebugFormat("SetGesture is {0} gestures: {1}", enabled ? "enabling" : "disabling", gestureTypes);
// TODO: Fix this hacky workaround when Razer fixes their code
var values =
Enum.GetValues(gestureTypes.GetType()).Cast <Enum>().Where(gestureTypes.HasFlag).Cast <GestureTypes>();
HRESULT result;
foreach (var value in values)
{
result = NativeMethods.RzSBEnableGesture(value, enabled);
if (HRESULT.RZSB_FAILED(result))
{
throw new NativeCallException("RzSBEnableGesture", result);
}
}
result = NativeMethods.RzSBGestureSetCallback(_gestureCallback);
if (HRESULT.RZSB_FAILED(result))
{
throw new NativeCallException("RzSBGestureSetCallback", result);
}
}
/// <summary>
/// Removes gesture if it's there.
/// </summary>
/// <param name="gesture"> Gesture to remove. </param>
public void RemoveGesture(GestureTypes gesture)
{
if ((gesture & _trackedGestures) == gesture)
{
_trackedGestures ^= gesture;
UpdateGestureStates(true);
}
}
// Called once application started
void Start()
{
// Always assume the gesture is touch
GestureType = GestureTypes.Touch;
// Initialize raycast result object
raycastResult = new List <RaycastResult>();
}
/// <summary>
/// Initializes a new instance of the <see cref="GestureEventArgs" /> class.
/// </summary>
/// <param name="gestureTypes">Type of gesture.</param>
/// <param name="parameter">Contextual parameter associated with the gesture.</param>
/// <param name="x">X position of gesture.</param>
/// <param name="y">Y position of gesture.</param>
/// <param name="z">Z position of gesture.</param>
internal GestureEventArgs(GestureTypes gestureTypes, uint parameter, ushort x, ushort y, ushort z)
{
_gestureTypes = gestureTypes;
_parameter = parameter;
_x = x;
_y = y;
_z = z;
}
/// <summary>
/// Adds gesture if it's not there already.
/// </summary>
/// <param name="gesture"> Gesture to add. </param>
public void AddGesture(GestureTypes gesture)
{
if ((gesture & _trackedGestures) != gesture)
{
_trackedGestures |= gesture;
UpdateGestureStates(true);
}
}
/// <summary>
/// Raises gesture event to subscribers.
/// </summary>
/// <param name="gestureTypes">Type of gesture.</param>
/// <param name="parameter">Contextual parameter associated with gesture.</param>
/// <param name="x">X position of gesture.</param>
/// <param name="y">Y position of gesture.</param>
/// <param name="z">Z position of gesture.</param>
private void OnGesture(GestureTypes gestureTypes, uint parameter, ushort x, ushort y, ushort z)
{
var func = Gesture;
if (func != null)
{
func(this, new GestureEventArgs(gestureTypes, parameter, x, y, z));
}
}
public bool ReceiveEvent(GestureTypes type)
{
if (gameManager.IsReadyUI())
{
currentType = type;
gameManager.UpdateUIBlockingGesture(type, TimeBetween2Gestures, UnBlockGesture);
return(true);
}
return(false);
}
public override bool ReceiveEvent(GestureTypes type)
{
if (_gameManager.IsReadyUI())
{
_currentType = type;
_gameManager.UpdateUIBlockingGesture(type, TimeBetween2Gestures, unBlockGesture);
_gameManager.NavigateMenu(type);
return(true);
}
return(false);
}
/// <summary>
/// Initializes a new <see cref="GestureSample"/>.
/// </summary>
public GestureSample(
GestureTypes gestureType,
TimeSpan timestamp,
Vector2 position1, Vector2 position2,
Vector2 delta1, Vector2 delta2)
{
GestureType = gestureType;
Timestamp = timestamp;
Position1 = position1;
Position2 = position2;
Delta1 = delta1;
Delta2 = delta2;
}
/// <summary>
/// Create a wired-up recognizer for running the slideshow.
/// </summary>
/// <returns>The wired-up recognizer.</returns>
private Recognizer CreateRecognizer()
{
// Instantiate a recognizer.
var recognizer = new Recognizer();
// Wire-up swipe right to manually advance picture.
recognizer.SwipeRightDetected += (s, e) =>
{
KinectSwipeDetected = GestureTypes.RightSwipe;
};
// Wire-up swipe left to manually reverse picture.
recognizer.SwipeLeftDetected += (s, e) =>
{
KinectSwipeDetected = GestureTypes.LeftSwipe;
};
return(recognizer);
}
/// <summary>
/// Get the gestures enabled in an MLStaticGestureType array.
/// </summary>
/// <returns> The array of gestures being tracked.</returns>
private MLStaticGestureType[] GetGestureTypes()
{
int[] enumValues = (int[])Enum.GetValues(typeof(GestureTypes));
List <MLStaticGestureType> gestures = new List <MLStaticGestureType>();
_currentGestures = 0;
GestureTypes current;
for (int i = 0; i < enumValues.Length; ++i)
{
current = (GestureTypes)enumValues[i];
if ((_trackedGestures & current) == current)
{
_currentGestures |= current;
gestures.Add((MLStaticGestureType)i);
}
}
return(gestures.ToArray());
}
/// <summary>
/// Detects finger movement for +-X or +-Y direction
/// </summary>
/// <param name="swipeDelta"></param>
private void DetectSwipe(Vector2 swipeDelta)
{
SwipeDirections SwipeDirection;
// Check finger movement distance is much more then threshold
if (swipeDelta.magnitude >= swipeThreshold)
{
// Assign gesture type to swipe to prevent touch event
GestureType = GestureTypes.Swipe;
// If movement on X axis, trigger right or left
// else trigger up or bottom
if (IsHorizontalSwipe(swipeDelta))
{
SwipeDirection = swipeDelta.x < 0 ? SwipeDirections.Left : SwipeDirections.Right;
}
else
{
SwipeDirection = swipeDelta.y < 0 ? SwipeDirections.Bottom : SwipeDirections.Up;
}
OnSwipe?.Invoke(SwipeDirection);
}
}
void UnBlockGesture(GestureTypes type)
{
Gesture behavior = (Gesture)listActiveGestures [type];
behavior.UnBlockGesture();
}
public void LoadingGestureProgress(GestureTypes type, float percent)
{
gameManager.UpdateUILoadingGesture(type, percent);
}
/// <summary>
/// Disables forwarding of a gesture.
/// </summary>
/// <param name="gestureTypes">Gesture to disable.</param>
public void DisableOSGesture(GestureTypes gestureTypes)
{
SetOSGesture(gestureTypes, false);
}
void LateUpdate()
{
if (Input.GetMouseButtonDown(0)){
velocityXInit = Mathf.Abs(velocityX);
velocityYInit = Mathf.Abs(velocityY);
Debug.Log ("MouseDown");
txtGesture.text = "MouseDown";
gesture = GestureTypes.MouseDown;
MouseDown();
} else
if (Input.GetMouseButton(0)){
velocityX += xSpeed * Input.GetAxis("Mouse X") * 0.02f;
velocityY += ySpeed * Input.GetAxis("Mouse Y") * 0.02f;
if ((Mathf.Abs(velocityX) > velocityXInit + dragTreshold) || (Mathf.Abs(velocityY) > velocityYInit + dragTreshold)){
if (gesture == GestureTypes.MouseDown){
Debug.Log ("DragBegin");
txtGesture.text = "DragBegin";
gesture = GestureTypes.DragBegin;
DragBegin();
}else{
Debug.Log ("DragOn");
txtGesture.text = "DragOn";
gesture = GestureTypes.DragOn;
DragOn();
}
}
} else
if (Input.GetMouseButtonUp(0)){
velocityXInit = Mathf.Abs(velocityX);
velocityYInit = Mathf.Abs(velocityY);
if (gesture == GestureTypes.DragOn){
Debug.Log ("DragEnd");
txtGesture.text = "DragEnd";
gesture = GestureTypes.DragEnd;
DragEnd();
}else{
Debug.Log ("MouseUp");
txtGesture.text = "MouseUp";
gesture = GestureTypes.MouseUp;
MouseUp();
}
}
// On each lateUpdate during selection phase:
// on clic:
if (gameManager != GameManager.Zoom) {
if((gesture == GestureTypes.MouseDown) || (gesture == GestureTypes.MouseUp)){
rotation = Quaternion.Slerp(transform.rotation, toRotation, Time.deltaTime * smoothTime);
}else{ // on drag:
rotationYAxis += velocityX;
rotationXAxis -= velocityY;
rotationXAxis = ClampAngle(rotationXAxis, yMinLimit, yMaxLimit);
toRotation = Quaternion.Euler(rotationXAxis, rotationYAxis, 0);
rotation = toRotation;
velocityX = Mathf.Lerp(velocityX, 0, Time.deltaTime * smoothTime);
velocityY = Mathf.Lerp(velocityY, 0, Time.deltaTime * smoothTime);
}
}else{
RaycastHit hit;
if (Physics.Raycast(transform.position, transform.forward, out hit, 20)){
distance = Mathf.Lerp(distance, hit.distance, Time.deltaTime * smoothTime /2);
//txtZone.text= "Zoom " + distance.ToString();
if (hit.distance > 5.0f){
blur = 0;
}else if (hit.distance < 0.6f){
Application.LoadLevel(2);
}else{
blur = Mathf.Abs(5-hit.distance) * 10;
}
txtZoom.text = blur.ToString();
be.blurSize = blur;
}
}
Vector3 negDistance = new Vector3(0.0f, 0.0f, -distance);
Vector3 position = rotation * negDistance + target.position;
transform.rotation = rotation;
transform.position = position;
}
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="e">Gesture event arguments.</param>
private void OnGestureRecognized(object sender, GestureEventArgs e)
{
switch (e.GestureName)
{
case "JoinedHands":
//KinectSwipeDetected = GestureTypes.JoinedHands;
break;
case "SwipeLeft":
KinectGestureDetected = GestureTypes.RightSwipe;
break;
case "SwipeRight":
KinectGestureDetected = GestureTypes.LeftSwipe;
break;
case "SwipeUp":
//KinectSwipeDetected = GestureTypes.SwipeUp;
break;
default:
break;
}
_clearTimer.Start();
}
/// <summary>
/// Handles the native gesture event sent from Razer SDK.
/// </summary>
/// <param name="gestureTypes">Type of gesture.</param>
/// <param name="parameters">Parameters associated with gesture event.</param>
/// <param name="x">X position.</param>
/// <param name="y">Y position.</param>
/// <param name="z">Z position.</param>
/// <returns><see cref="HRESULT" /> object indicating success or failure.</returns>
private HRESULT HandleTouchpadGesture(GestureTypes gestureTypes, uint parameters, ushort x, ushort y, ushort z)
{
OnGesture(gestureTypes, parameters, x, y, z);
switch (gestureTypes)
{
case GestureTypes.Press:
OnPress(parameters, x, y);
break;
case GestureTypes.Tap:
OnTap(x, y);
break;
case GestureTypes.Flick:
{
var direction = (Direction)z;
OnFlick(parameters, direction);
break;
}
case GestureTypes.Zoom:
{
ZoomDirection direction;
switch (parameters)
{
case 1:
direction = ZoomDirection.In;
break;
case 2:
direction = ZoomDirection.Out;
break;
default:
direction = ZoomDirection.Invalid;
break;
}
OnZoom(direction);
break;
}
case GestureTypes.Rotate:
{
RotateDirection direction;
switch (parameters)
{
case 1:
direction = RotateDirection.Clockwise;
break;
case 2:
direction = RotateDirection.Counterclockwise;
break;
default:
direction = RotateDirection.Invalid;
break;
}
OnRotate(direction);
break;
}
case GestureTypes.Move:
OnMove(x, y);
break;
case GestureTypes.Hold:
OnHold(parameters, x, y, z);
break;
case GestureTypes.Release:
OnRelease(parameters, x, y);
break;
case GestureTypes.Scroll:
OnScroll(parameters, x, y, z);
break;
}
return(HRESULT.RZSB_OK);
}
internal static extern HRESULT RzSBEnableGesture(
[In] GestureTypes gestureTypes,
[In][MarshalAs(UnmanagedType.U1)] bool enable);
protected void unBlockGesture(GestureTypes type)
{
BehaviorHand behavior = (BehaviorHand)_listActiveGestures [type];
behavior.UnBlockGesture();
}
/// <summary>
/// Enables a gesture to be forwarded to the host operating system.
/// </summary>
/// <param name="gestureTypes">Gesture to forward.</param>
public void EnableOSGesture(GestureTypes gestureTypes)
{
SetOSGesture(gestureTypes, true);
}
/// <summary>
/// Clear text after some time
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void clearTimer_Elapsed(object sender, ElapsedEventArgs e)
{
kinectGestureDetected = GestureTypes.None;
_clearTimer.Stop();
}
public CustomGesture(Frame frame)
{
currentFrame = frame;
//immediately check to see if the frame contains a custom gesture
GestureType = DetermineGesture();
}
/// <summary>
/// Clear text after some time
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void clearTimer_Elapsed(object sender, ElapsedEventArgs e)
{
kinectGestureDetected = GestureTypes.None;
_clearTimer.Stop();
}
/// <summary>
/// Create a wired-up recognizer for running the slideshow.
/// </summary>
/// <returns>The wired-up recognizer.</returns>
private Recognizer CreateRecognizer()
{
// Instantiate a recognizer.
var recognizer = new Recognizer();
// Wire-up swipe right to manually advance picture.
recognizer.SwipeRightDetected += (s, e) =>
{
KinectSwipeDetected = GestureTypes.RightSwipe;
};
// Wire-up swipe left to manually reverse picture.
recognizer.SwipeLeftDetected += (s, e) =>
{
KinectSwipeDetected = GestureTypes.LeftSwipe;
};
return recognizer;
}
// Use this for initialization
void Start()
{
gesture = GestureTypes.None;
gameManager = GameManager.Start;
currentZone = Zones.none;
ResetZonesColor();
// init cam position
toRotation = transform.rotation;
rotation = toRotation;
Vector3 negDistance = new Vector3(0.0f, 0.0f, -distance);
Vector3 position = rotation * negDistance + target.position;
transform.rotation = rotation;
transform.position = position;
Vector3 angles = transform.eulerAngles;
rotationYAxis = angles.y;
rotationXAxis = angles.x;
// Make the rigid body not change rotation
if (GetComponent<Rigidbody>())
{
GetComponent<Rigidbody>().freezeRotation = true;
}
be = GetComponent<Camera>().GetComponent<Blur>();
audio = GetComponent<AudioSource>();
}
public virtual void LoadingGestureProgress(GestureTypes type, float percent)
{
}
