/*****************************************************
* UPDATE HAND & FINGERTIP IMAGE
*
* INFO: Affiche en temps réel la detection de la
* main gauche et droite.
* Affiche les doigts qui sont détectés par
* le LeapMotion pour la main gauche et droite.
*
*****************************************************/
private void UpdateHandFingertipImage()
{
// Main gauche
if (DetectionController.GetInstance().IsHandDetected(HandsE.gauche))
{
// Controleur de la main gauche
Hand leftHand = DetectionController.GetInstance().GetHand(HandsE.gauche).GetLeapHand();
//Un point vert (image) est affiché si le doigt de la main gauche est détecté
L_Hand.enabled = true;
L_Thumb.enabled = leftHand.GetThumb().IsExtended ? true : false;
L_Index.enabled = leftHand.GetIndex().IsExtended ? true : false;
L_Majeur.enabled = leftHand.GetMiddle().IsExtended ? true : false;
L_Annulaire.enabled = leftHand.GetRing().IsExtended ? true : false;
L_Auriculaire.enabled = leftHand.GetPinky().IsExtended ? true : false;
}
// Main droite
if (DetectionController.GetInstance().IsHandDetected(HandsE.droite))
{
// Controleur de la main droite
Hand rightHand = DetectionController.GetInstance().GetHand(HandsE.droite).GetLeapHand();
//Un point vert (image) est affiché si le doigt de la main droite est détecté
R_Hand.enabled = true;
R_Thumb.enabled = rightHand.GetThumb().IsExtended ? true : false;
R_Index.enabled = rightHand.GetIndex().IsExtended ? true : false;
R_Majeur.enabled = rightHand.GetMiddle().IsExtended ? true : false;
R_Annulaire.enabled = rightHand.GetRing().IsExtended ? true : false;
R_Auriculaire.enabled = rightHand.GetPinky().IsExtended ? true : false;
}
}
/*****************************************************
* UPDATE
*
* INFO: Recupere la distance du scaling et met à jour
* l'objet à chaque frame. Un amplificateur de
* mouvement est utilisé pour faciliter le
* redimensionnement.
*
* Ex: Si l'amplificateur est de 2.0f et que les
* mains se déplacent de 1" vers l'extérieur,
* l'objet va grossir de 2" dans tous les sens.
*
*****************************************************/
void Update()
{
//Si la manipulation contrôlé d'objet est activé et que les deux mains sont détectés.
if (isScaling && DetectionController.GetInstance().IsBothHandsDetected() &&
PalmUIController.GetInstance().IsManipulationControlled())
{
//La liste des objets sélectionnés avec le raycast
List <SelectedObject> objectsToScaleList = SelectionController.GetInstance().GetSelectedObjects();
if (objectsToScaleList.Count > 0)
{
float newDistance = GetDistance();
float distance = newDistance - lastDistance;
foreach (SelectedObject objectToScale in objectsToScaleList)
{
// Met à jour la dimension de l'objet (X,Y,Z) avec l'amplificateur pris en compte.
objectToScale.TransformObject.localScale += new Vector3(distance, distance, distance) * amplifyScale;
// Évite que le redimensionnement de l'objet soit trop petit ou trop grand
if (objectToScale.GetScale().x < minimumScale)
{
objectToScale.TransformObject.localScale = new Vector3(minimumScale, minimumScale, minimumScale);
}
if (objectToScale.GetScale().x > maximumScale)
{
objectToScale.TransformObject.localScale = new Vector3(maximumScale, maximumScale, maximumScale);
}
}
lastDistance = newDistance;
}
}
}
/*****************************************************
* DETECTED FIST GESTURE
*
* INFO: Valide la détection du geste qui consiste
* à effectuer un glissement de la main.
* La fonction communique directement avec le
* médiateur du contrôleur de gestes.
*
* *** TO CHECK RIGHT SWIPE ***
*
*****************************************************/
public override bool IsDetectedGesture()
{
bool isSwiping = false;
swipeDirection = "";
if (DetectionController.GetInstance().IsHandDetected(hand) && coolDownLeft <= 0.0f)
{
// Sert simplement de reference
DirectionsE _direction = DirectionsE.droite;
// Vérifie si la reference du geste est de type 'Swipe'
if (IsHandSwiping(ref _direction))
{
// Si la reference equivaut bien au sens du glissement entré en paramètre
if (_direction == direction)
{
swipeDirection = direction.ToString();
coolDownLeft = cooldownTime;
isSwiping = true;
}
}
}
DisplayDectedGesture(isSwiping);
return(isSwiping);
}
/*****************************************************
* UPDATE THUMB/INDEX ROTATION
*
* INFO: Maintient à jour la rotation de l'objet 3D
* en fonction du pouce et de l'index de la main.
* Ajuste dynamiquement la vitesse de rotation
* selon la position du ou des doigts qui
* causent la rotation. C'est ici qu'on valide
* quels sont les doigts ouverts.
*
* *** TO OPTIMIZE ***
*
*****************************************************/
private void ThumbIndexRotation()
{
//Si la main qui permet d'effecuer la rotation est détectée.
//Si la manipulation contrôlé d'objet est activé.
if (DetectionController.GetInstance().IsHandDetected(ThumbOrIndexGesture.GetInstance().GetHand()) &&
PalmUIController.GetInstance().IsManipulationControlled())
{
//La liste des objets sélectionnés avec le raycast
List <SelectedObject> objectsToRotateList = SelectionController.GetInstance().GetSelectedObjects();
if (objectsToRotateList.Count > 0)
{
//Recupère le contrôleur de la la main
detectedHand = DetectionController.GetInstance().GetHand(ThumbOrIndexGesture.GetInstance().GetHand());
//Change l'etat des doigts si le pouce et/ou l'index est ouvert
if (detectedHand.GetFinger(FingersE.pouce).IsFingerOpen() || detectedHand.GetFinger(FingersE.index).IsFingerOpen())
{
isThumbOpen = detectedHand.GetFinger(FingersE.pouce).IsFingerOpen() ? true : false;
isIndexOpen = detectedHand.GetFinger(FingersE.index).IsFingerOpen() ? true : false;
}
foreach (SelectedObject objectToRotate in objectsToRotateList)
{
//Applique la rotation en fonction de la force
Vector3 rotationSpeed = stopPosition * amplifyFingerRotation;
Vector3 dynamicRotation = objectToRotate.TransformObject.worldToLocalMatrix * rotationSpeed;
objectToRotate.TransformObject.Rotate(dynamicRotation);
startPosition = Vector3.Lerp(stopPosition, Vector3.zero, Time.deltaTime);
}
}
}
}
/*****************************************************
* DETECTED FIST GESTURE
*
* INFO: Valide la détection du geste qui consiste
* à tapper des mains. La fonction
* communique directement avec le médiateur
* du contrôleur de gestes.
*
*****************************************************/
public override bool IsDetectedGesture()
{
bool isClapping = false;
//Si les deux mains sont visibles
if (DetectionController.GetInstance().IsBothHandsVisible() && cooldownLeft <= 0.0f)
{
//La main gauche et droite
DetectionController.HandController leftHand = DetectionController.GetInstance().GetHand(HandsE.gauche);
DetectionController.HandController rightHand = DetectionController.GetInstance().GetHand(HandsE.droite);
if (leftHand.GetHandVelocity().magnitude >= clapSpeed &&
rightHand.GetHandVelocity().magnitude >= clapSpeed)
{
//Si les deux mains sont assez proche l'une de l'autre
if (DetectionController.GetInstance().GetDistanceBetweenHands() <= handsDistance)
{
cooldownLeft = cooldownTime;
isClapping = true;
}
}
}
DisplayDectedGesture(isClapping);
return(isClapping);
}
/*****************************************************
* METHOD: UPDATE
*
* INFO: Recupere la distance de la translation et met
* à jour l'objet à chaque frame. Un amplificateur
* de mouvement est utilisé pour faciliter les
* déplacements.
*
* Ex: Si l'amplificateur est de 2.0f et que la
* main se déplace de 1" vers la gauche, l'objet
* va se déplacer de 2" vers la gauche.
*
*****************************************************/
void Update()
{
//Si la manipulation contrôlé d'objet est activé
if (PalmUIController.GetInstance().IsManipulationControlled())
{
// Si la main initialisé avec le geste Fist est détecté, on effectue une translation
if (isTranslating && DetectionController.GetInstance().IsHandDetected(hand))
{
//La liste des objets sélectionnés avec le raycast
List <SelectedObject> objectsToTranslateList = SelectionController.GetInstance().GetSelectedObjects();
if (objectsToTranslateList.Count > 0)
{
// Calcul la distance du déplacement
Vector3 newHandPosition = GetStartHandPosition();
Vector3 handDistance = newHandPosition - lastHandPosition;
foreach (SelectedObject objectToTranslate in objectsToTranslateList)
{
// Met à jour la position de l'objet (X,Y,Z) avec l'amplificateur pris en compte.
objectToTranslate.TransformObject.position += handDistance * amplifyMovement;
}
lastHandPosition = newHandPosition;
}
}
}
}
/*****************************************************
* DETECTED ONLY INDEX GESTURE
*
* INFO: Retourne vrai si seulement ce doigt est ouvert.
*
*****************************************************/
public override bool IsDetectedGesture()
{
//Si la main du geste n'est pas détectée.
if (!DetectionController.GetInstance().IsHandDetected(hand))
{
return(false);
}
DetectionController.HandController handController = DetectionController.GetInstance().GetHand(hand);
onlyThisFingerOpened = false;
//Pour tous les doigts de la main, partant de l'auriculaire
for (int i = 0; i < (int)FingersE.auriculaire; i++)
{
FingersE _finger = FingersE.pouce + i;
if (handController.GetFinger(_finger).IsFingerOpen())
{
//Verifie si seulement le doigt est ouvert et que les autres sont fermés
if (_finger == finger)
{
onlyThisFingerOpened = true;
}
else
{
return(false);
}
}
}
DisplayDectedGesture(onlyThisFingerOpened);
return(onlyThisFingerOpened);
}
/*****************************************************
* GET POSITION
*
* INFO: Retourne la position (x,y,z) de la main
* qui effectue la geste Fist.
*
*****************************************************/
private Vector3 GetStartHandPosition()
{
return(DetectionController
.GetInstance()
.GetHand(hand)
.GetHandPosition());
}
/*****************************************************
* DETECTED SINGLE FINGER GESTURE
*
* INFO: Valide la détection du geste qui consiste à
* garder le pouce ou l'index ou l'index et le pouce
* ouvert.La fonction communique directement avec
* le médiateur du contrôleur de gestes.
*
*****************************************************/
public override bool IsDetectedGesture()
{
bool isFingerOpen = false;
//Si la main est détectée
if (DetectionController.GetInstance().IsHandDetected(hand))
{
//Recupère le contrôleur de la la main
DetectionController.HandController detectedHand = DetectionController.GetInstance().GetHand(hand);
for (int i = 0; i < 4; i++)
{
if (detectedHand.GetFinger((FingersE)i).IsFingerOpen())
{
//Si le ou les bons doigts de la main sont ouverts
if ((FingersE)i == FingersE.pouce || (FingersE)i == FingersE.index)
{
isFingerOpen = true;
}
else
{
return(false);
}
}
}
}
//DisplayDectedGesture(isFingerOpen);
return(isFingerOpen);
}
/*****************************************************
*
*
* INFO:
*
*****************************************************/
private void MoveWithBothHands()
{
if (isMoving && isHandSet && !isMovingPaused &&
DetectionController.GetInstance().IsHandDetected(HandsE.gauche) &&
DetectionController.GetInstance().IsHandDetected(HandsE.droite))
{
}
}
/*****************************************************
* GEST DISTANCE
*
* INFO: Retourne la distance entre l'index (doigt)
* de la main gauche et l'index (doigt) de la
* main droite.
*
*****************************************************/
private float GetDistance()
{
//Le doigt (index) de la main gauche et droite
Vector3 leftFingerPosition = DetectionController.GetInstance().GetHand(HandsE.gauche).GetFinger(FingersE.index).GetFingertipPosition();
Vector3 rightFingerPosition = DetectionController.GetInstance().GetHand(HandsE.droite).GetFinger(FingersE.index).GetFingertipPosition();
return(Vector3.Distance(leftFingerPosition, rightFingerPosition));
}
public override void OnDestroy()
{
DetectionController dc = gameObject.GetComponent <DetectionController>();
dc.isAbleToRecord = true;
//reset
gameObject.GetComponent <SpriteRenderer>().color = Color.white;
base.OnDestroy();
}
/*****************************************************
* UPDATE SWIPE ROTATION
*
* INFO: Evenement qui permet de maintenir a jour la
* rotation de l'objet lorsque l'utilisateur effectue
* un geste Swipe.
*
* *** TO OPTIMIZE ***
*
*****************************************************/
public void UpdateSwipeRotation()
{
//Si la manipulation contrôlé d'objet est activé
if (PalmUIController.GetInstance().IsManipulationControlled())
{
//La liste des objets sélectionnés avec le raycast
List <SelectedObject> objectsToRotateList = SelectionController.GetInstance().GetSelectedObjects();
if (objectsToRotateList.Count > 0)
{
//Le type de Swipe effectué (gauche, droite, haut, bas)
swipeType = GestureMediator.GetGestureType();
if (swipeType.Contains("Swipe"))
{
foreach (SelectedObject objectToRotate in objectsToRotateList)
{
detectedHand = DetectionController.GetInstance().GetHand(GestureMediator.GetDetectedHand());
float velocityX = 0f;
float velocityY = 0f;
//La velocité du swipe en X ou Y
if (isRotationX)
{
velocityX = -detectedHand.GetHandVelocity().x;
}
if (isRotationY)
{
velocityY = detectedHand.GetHandVelocity().y;
}
allowCoroutine = true;
//Rotation horizontale (Swipe gauche ou droite)
if (isRotationX && (swipeType.Contains("droite") || swipeType.Contains("gauche")))
{
//Demarre la rotation horizontale selon le type choisi (swipe lock angle / swipe velocity)
Vector3 axis = Mathf.Sign(velocityX) * Vector3.up;
StartCoroutine(isLockRotation ?
RotateWhenSwipe(objectToRotate.TransformObject, axis, rotationAngle, secondsToRotate) :
RotateFreeWhenSwipe(objectToRotate.TransformObject, axis, velocityX));
}
//Rotation verticale (Swipe haut ou bas)
if (isRotationY && (swipeType.Contains("haut") || swipeType.Contains("bas")))
{
//Demarre la rotation verticale selon le type choisi (swipe lock angle / swipe velocity)
Vector3 axis = Mathf.Sign(velocityY) * Vector3.right;
StartCoroutine(isLockRotation ?
RotateWhenSwipe(objectToRotate.TransformObject, axis, rotationAngle, secondsToRotate) :
RotateFreeWhenSwipe(objectToRotate.TransformObject, axis, velocityY));
}
}
}
}
}
}
/*****************************************************
* DETECTED FIST GESTURE
*
* INFO: Valide la détection du geste qui consiste
* à fermer la main (poing). La fonction
* communique directement avec le médiateur
* du contrôleur de gestes.
*
*****************************************************/
public override bool IsDetectedGesture()
{
isFisting = false;
if (DetectionController.GetInstance().IsHandDetected(hand))
{
DetectionController.HandController handController = DetectionController.GetInstance().GetHand(hand);
isFisting = handController.IsFist(tolerance) && handController.IsAllFingersClosed() && !BothFistGesture.GetInstance().IsBothFisting();
}
DisplayDectedGesture(isFisting);
return(isFisting);
}
/*****************************************************
* GET RELATIVE HAND POSITION
*
* INFO: Retourne la position relative de la main.
*
*****************************************************/
Vector3 GetRelativeHandPosition()
{
if (DetectionController.GetInstance().IsHandDetected(hand))
{
return(DetectionController
.GetInstance()
.GetHand(hand)
.GetRelativeHandPosition());
}
return(Vector3.zero);
}
/*****************************************************
* GET HAND AXIS
*
* INFO: Retourne l'axe (vecteur) que prend les doigts
* de la main pour rendre le déplacement plus
* dynamique.
*
*****************************************************/
public Vector3 GetHandAxis()
{
if (DetectionController.GetInstance().IsHandDetected(hand))
{
return(DetectionController
.GetInstance()
.GetHand(hand)
.GetAxis(HandAxisE.doigt));
}
return(Vector3.zero);
}
/*****************************************************
* UPDATE
*
* INFO:
*
*****************************************************/
void Update()
{
if (DetectionController.GetInstance().IsHandDetected(HandsE.gauche) && !isPalmUIInitialized)
{
if (DetectionController.GetInstance().IsHandDetected(HandsE.gauche) && !isPalmUIInitialized)
{
//Activation de depart du Palm UI
manipulationType.SetActive(true);
isPalmUIInitialized = true;
}
}
}
public override void Start()
{
//Disable detection of this gameObject
DetectionController dc = gameObject.GetComponent <DetectionController>();
dc.isAbleToRecord = false;
//Blending
renderer = gameObject.GetComponent <SpriteRenderer>();
renderer.color = blend;
delta = 0f;
//Calling base start
base.Start();
}
/*****************************************************
* DETECTED PINCH GESTURE
*
* INFO: Valide la détection du geste qui consiste à
* effectuer un pincement de doigt. La fonction
* communique directement avec le médiateur
* du contrôleur de gestes.
*
*****************************************************/
public override bool IsDetectedGesture()
{
bool isPinching = false;
if (DetectionController.GetInstance().IsHandDetected(hand))
{
//Valide si la tolerance est respectée et évite la confusion avec double pincement et le poing
isPinching = DetectionController.GetInstance().GetHand(hand).IsHandPinching(tolerance) &&
!BothPinchGesture.GetInstance().IsBothPinching() && !FistGesture.GetInstance().IsFisting() &&
!OneFingerGesture.GetInstance().IsPointing();
}
DisplayDectedGesture(isPinching);
return(isPinching);
}
/*****************************************************
* UPDATE - TARGET OBJECT
*
* INFO: Detection de l'action qui consiste a effectuer
* un tir (trigger) avec le pouce lorsque la main
* fait un geste de fusil (pouce et index).
*
*****************************************************/
void Update()
{
isGunActionDetected = false;
//Si le Palm UI n'est pas ouvert et la main droite détecté
if (!PalmUIController.GetInstance().IsPalmUIOpen() &&
DetectionController.GetInstance().IsHandDetected(raycastHand))
{
//Étape 1: l'index et le pouce (fusil) sont ouverts
if (wasOnlyIndexThumbOpen)
{
//Étape 2: le pouce est désormais fermé (trigger) et l'index est ouvert
if (isOnlyIndexOpen && !isOnlyIndexThumbOpen)
{
//Le temps du trugger (pouce: ouvert --> fermé --> ouvert)
timer += Time.deltaTime;
}
//Étape 3: l'index et le pouce sont ouverts à nouveau et le trigger respecte le delais
if (timer < triggerTimer && timer > 0f && wasOnlyIndexOpen && isOnlyIndexThumbOpen)
{
isGunActionDetected = true;
timer = 0f;
}
//Pour tout déselectionner les objets, on maintient le pouce descendu plus longtemps
if (timer > timeBeforeUnselect && timer > triggerTimer && isOnlyIndexOpen && !isOnlyIndexThumbOpen)
{
//Change le materiel de couleur (rouge)
UnselectAllObjects(false);
}
//Si apres prolongation du pouce fermé et qu'on le relève, désélectionne tous les objets.
if (timer > timeBeforeUnselect && timer > triggerTimer && wasOnlyIndexOpen && isOnlyIndexThumbOpen)
{
//Remet le materiel par defaut et vide les liste de sélection
UnselectAllObjects(true);
timer = 0f;
}
//timer = 0f;
}
//Si on ne pointe pas et que le geste Gun (pouce et index) n'est pas détecté
if (!isOnlyIndexOpen && !isOnlyIndexThumbOpen)
{
ResetAllState();
}
}
else
{
ResetAllState();
}
}
/*****************************************************
* IS HAND SWIPING
*
* INFO: Valide le sens du glissement effectuée par
* la main et retourne la reponse.
*
*****************************************************/
bool IsHandSwiping(ref DirectionsE _direction)
{
// Recupere le controleur de la main détectée
DetectionController.HandController detectHand = DetectionController.GetInstance().GetHand(hand);
// Recupere la velocité de la main
Vector3 velocity = detectHand.GetHandVelocity();
velocity = Camera.main.transform.InverseTransformDirection(velocity);
// Glissement vers la droite (+X)
if (velocity.x >= this.velocity)
{
_direction = DirectionsE.droite;
return(true);
}
// Glissement vers la gauche (-X)
else if (velocity.x <= -this.velocity)
{
_direction = DirectionsE.gauche;
return(true);
}
// Glissement vers le haut (+Y)
else if (velocity.y >= this.velocity)
{
_direction = DirectionsE.haut;
return(true);
}
// Glissement vers le bas (-Y)
else if (velocity.y <= -this.velocity)
{
_direction = DirectionsE.bas;
return(true);
}
// Glissement vers l'interieur (+Z)
else if (velocity.z >= this.velocity)
{
_direction = DirectionsE.interieur;
return(true);
}
// Glissement vers l'exterieur (-Z)
else if (velocity.z <= -this.velocity)
{
_direction = DirectionsE.exterieur;
return(true);
}
return(false);
}
/*****************************************************
* DETECTED FIST GESTURE
*
* INFO: Valide la détection du geste qui consiste
* à fermer les deux mains (poing). La fonction
* communique directement avec le médiateur
* du contrôleur de gestes.
*
*****************************************************/
public override bool IsDetectedGesture()
{
isBothFist = false;
if (DetectionController.GetInstance().IsHandDetected(HandsE.gauche) &&
DetectionController.GetInstance().IsHandDetected(HandsE.droite))
{
DetectionController.HandController leftHand = DetectionController.GetInstance().GetHand(HandsE.gauche);
DetectionController.HandController rightHand = DetectionController.GetInstance().GetHand(HandsE.droite);
isBothFist = leftHand.IsFist(tolerance) && leftHand.IsAllFingersClosed() &&
rightHand.IsFist(tolerance) && rightHand.IsAllFingersClosed();
}
DisplayDectedGesture(isBothFist);
return(isBothFist);
}
// Update is called once per frame
void Update()
{
if (DetectionController.GetInstance().IsHandDetected(hand))
{
handController = DetectionController.GetInstance().GetHand(hand);
//Si le doigt du raycast est le seul d'ouvert et le Palm UI n'est pas affiché
if (handController.IsIndexOpened()) //&& !PalmUIController.GetInstance().IsPalmUIOpen()
{
//La position du bout du foigt et la direction auquelle il pointe
fingerController = handController.GetFinger(finger);
light.transform.position = fingerController.GetFingertipPosition();
light.transform.rotation = Quaternion.LookRotation(fingerController.GetFingerDirection());
}
}
}
// ***En cours*** Événements d'entrées et de sorties de la main gauche et droite.
//public UnityEvent leftHandEnter = null;
//public UnityEvent leftHandExit = null;
//public UnityEvent rightHandEnter = null;
//public UnityEvent rightHandExit = null;
/*****************************************************
* AWAKE
*
* INFO: Initialise l'instance de la classe ainsi que
* le contrôleur de chaque main et recupère le
* fournisseur de service LeapMotion.
*
*****************************************************/
void Awake()
{
//Initialise l'instance de cette classe
if (instance == null)
{
instance = this;
}
else
{
Destroy(this);
}
leapService = FindObjectOfType <LeapXRServiceProvider>();
leftHandController = new HandController();
rightHandController = new HandController();
}
/*****************************************************
* DETECTED BOTH PINCH GESTURE
*
* INFO: Valide la détection du geste qui consiste à
* effectuer un pincement de doigts avec les
* deux mains. La fonction communique directement
* avec le médiateur du contrôleur de gestes.
* Pincement du pouce et de l'index.
*
*****************************************************/
public override bool IsDetectedGesture()
{
isBothPinch = false;
if (DetectionController.GetInstance().IsBothHandsDetected() && DetectionController.GetInstance().IsBothHandsVisible())
{
//Tolerence acceptable du pincement
bool leftHandPinching = DetectionController.GetInstance().GetHand(HandsE.gauche).IsHandPinching(tolerance);
bool rightHandPinching = DetectionController.GetInstance().GetHand(HandsE.droite).IsHandPinching(tolerance);
//Pincement avec l'index et le pouce
bool leftIndexThumbPinch = DetectionController.GetInstance().GetHand(HandsE.gauche).IsPinchDistance(distance);
bool rightIndexThumbPinch = DetectionController.GetInstance().GetHand(HandsE.droite).IsPinchDistance(distance);
isBothPinch = leftHandPinching && rightHandPinching && leftIndexThumbPinch && rightIndexThumbPinch && !BothFistGesture.GetInstance().IsBothFisting();
}
DisplayDectedGesture(isBothPinch);
return(isBothPinch);
}
/*****************************************************
* UPDATE FIST AND PINCH SLIDERS
*
* INFO: Affiche en temps réel le niveau de détection
* des gestes Fist et Pinch pour les deux mains.
*
* *** PROBLEM ***
* Les sliders de la main gauche fonctionnent
* seulement si la main droite est détectée.
*
*****************************************************/
private void UpdateFistPinchSliders()
{
// Main gauche détectée
if (DetectionController.GetInstance().IsHandDetected(HandsE.gauche))
{
// Recupere la force du Fist et du Pinch pour la main gauche
Hand leftHand = DetectionController.GetInstance().GetHand(HandsE.gauche).GetLeapHand();
leftFistSlider.value = leftHand.GetFistStrength();
leftPinchSlider.value = -leftHand.PinchDistance;
leftFistSlider.image.color = leftFistSlider.value >= tolerance ? Color.green : Color.gray;
if (leftHand.GetFistStrength() > tolerance)
{
leftPinchSlider.value = -100;
leftPinchSlider.image.color = Color.gray;
}
else
{
leftPinchSlider.image.color = leftPinchSlider.value >= -20f ? Color.green : Color.gray;
}
}
// Main droite détectée
if (DetectionController.GetInstance().IsHandDetected(HandsE.droite))
{
// Recupere la force du Fist et du Pinch pour la main droite
Hand rightHand = DetectionController.GetInstance().GetHand(HandsE.droite).GetLeapHand();
rightFistSlider.value = rightHand.GetFistStrength();
rightPinchSlider.value = -rightHand.PinchDistance;
rightFistSlider.image.color = rightFistSlider.value >= tolerance ? Color.green : Color.gray;
if (rightHand.GetFistStrength() > tolerance)
{
rightPinchSlider.value = -100;
rightPinchSlider.image.color = Color.gray;
}
else
{
rightPinchSlider.image.color = rightPinchSlider.value >= -20f ? Color.green : Color.gray;
}
}
}
/*****************************************************
* UPDATE CLAP HAND SLIDERS
*
* INFO: ...
*
*****************************************************/
private void UpdateClapSliders()
{
//Recupere le type de geste détecté
string gesture = GestureMediator.GetGestureType();
if (gesture.Contains("Clap"))
{
if (DetectionController.GetInstance().IsHandDetected(HandsE.gauche) &&
GestureMediator.GetDetectedHand() == HandsE.gauche)
{
StartCoroutine(SwipeSliderTimer(clapLeftHand));
}
if (DetectionController.GetInstance().IsHandDetected(HandsE.droite) &&
GestureMediator.GetDetectedHand() == HandsE.droite)
{
StartCoroutine(SwipeSliderTimer(clapRightHand));
}
}
}
/*****************************************************
* UPDATE
*
* INFO: Deplace un objet de sa position vers celle
* de la camera en un temps donné.
*
*****************************************************/
void Update()
{
//La main utilisé pour sélectionner un objet 3D
DetectionController.HandController handController = DetectionController.GetInstance().GetHand(SelectionController.GetInstance().GetHand());
if (handController.IsHandSet())
{
//La liste des objets sélectionnés avec le raycast
List <SelectedObject> objectsToPullList = SelectionController.GetInstance().GetSelectedObjects();
if (objectsToPullList.Count > 0)
{
foreach (SelectedObject objectToPull in objectsToPullList)
{
//Pour rapprocher (tirer) l'objet
if (isReadyToPull && isPullObject)
{
isPullObject = false;
wasPullingObject = true;
//La position de la camera avec un offset pour garder une certaine distance avec l'objet
Transform camera = Camera.main.transform;
Vector3 cameraPosition = camera.position + camera.forward * offsetToCamera;
//Demarre le deplacement de l'objet vers la camera aen un temps donné
StartCoroutine(MoveToPosition(objectToPull, cameraPosition, translationTime));
}
//Pour remettre (pousser) l'objet a sa position initial
if (isReadyToPush && isPushBackObject && wasPullingObject)
{
isPushBackObject = false;
wasPullingObject = false;
//Demarre le deplacement de l'objet vers sa position initiale apres avoir tiré l'objet
StartCoroutine(MoveToPosition(objectToPull, objectToPull.GetInitialPosition(), translationTime));
}
}
}
}
}
/*****************************************************
* UPDATE RAYCAST DISTANCE
*
* INFO: Affiche la distance entre le bout du doigt
* qui a le raycast et l'objet 3D pointé.
*
*****************************************************/
private void UpdateRaycastDistance()
{
//*** TO OPTIMIZE ***
if (SelectionController.GetInstance() != null)
{
if (DetectionController.GetInstance().IsHandDetected(SelectionController.GetInstance().GetHand()))
{
float raycastDistance = SelectionController.GetInstance().GetRaycastDistance();
if (raycastDistance > 0f)
{
raycastLabel.text = "Contact dist.: " +
SelectionController.GetInstance().GetRaycastDistance().ToString("F2") + " m";
}
else
{
raycastLabel.text = "Contact dist.: n/a";
}
}
}
}
/*****************************************************
* DETECTED ONLY INDEX AND THUMB GESTURE
*
* INFO: Retourne vrai si seulement le pouce et
* l'index sont ouverts.
*
*****************************************************/
public override bool IsDetectedGesture()
{
bool isGunGesture = false;
//Si la bonne main est détectée
if (DetectionController.GetInstance().IsHandDetected(hand))
{
bool isIndexOpen = false;
bool isThumbOpen = false;
DetectionController.HandController handController = DetectionController.GetInstance().GetHand(hand);
//Pour tous les doigts de la main
foreach (DetectionController.FingerController finger in handController.GetFingers())
{
//Verifie si l'index et le pouce sont ouverts et que les autres doigts sont fermés
if (finger == handController.GetFinger(FingersE.index) || finger == handController.GetFinger(FingersE.pouce))
{
if (finger == handController.GetFinger(FingersE.index))
{
isIndexOpen = finger.IsFingerOpen();
}
if (finger == handController.GetFinger(FingersE.pouce))
{
isThumbOpen = finger.IsFingerOpen();
}
}
//else if (finger == handController.GetFinger(Fingers5.pouce)) { isOnlyIndexThumbOpen = finger.IsFingerOpen(); }
else
{
if (finger.IsFingerOpen())
{
isIndexOpen = isThumbOpen = false;
}
}
}
isGunGesture = isIndexOpen && isThumbOpen;
}
DisplayDectedGesture(isGunGesture);
return(isGunGesture);
}
