Vous êtes sur la page 1sur 32

Tutoriel 2 : Implementing Gaze Interaction

A.Mesbah

Placer des modèles 3D


Vous allez meubler votre pièce réalisée dans TP 1 avec certains des modèles 3D que vous allez
télécharger depuis Unity Asset Store. Et puis vous allez comprendre comment fonctionne Unity
Physics.

Téléchargez des modèles de meuble à partir de Window > Asset Store (chaise, table et lampe), puis
placez-les dans la pièce déjà créée simplement en les faisant glisser.

Vous pouvez modifier ces éléments, comme la taille, puis appliquez cela au préfabriqué (prefab) pour
s’assurer que toute table ou chaise que vous placez sont toujours de la même taille.

• Unity physics

Maintenant vous allez voir l’utilité de Unity Physics. Tout d’abord, vous devez examiner l'un des
objets de votre scène et voir s'il contient déjà des composants physiques. Parfois, les modèles de
l'Asset Store viendront avec des pièces physiques déjà attachées.

Pour ajouter un collisionneur à une chaise, cliquez sur add component, et pour l'instant, utilisez un
collisionneur de boîte ‘box collider’, vous remarquerez que Unity adapte en fait le collisionneur de
boîte à la chaise du mieux qu'elle le peut.

1
Appliquez votre prefab pour que toutes les autres chaises auront également des box colliders autour
d'elles. Vous pouvez maintenant faire la même chose pour la table.

Les collisionneurs ne sont que des surfaces solides contre lesquelles les choses peuvent rebondir. Il
n'y a pas encore de physique en cours. Cela nécessite un composant de corps rigide (Rigid Body
Component).

Alors testez cela avec l'une des chaises et élevez-la un peu au-dessus du sol pour que vous puissiez voir
les effets de la physique.

Ajoutez un corps rigide (add component > rigid body), puis cliquez sur Play. Vous allez remarquer que
la chaise vient de tomber et atterrir sur le sol parce que le sol a déjà un collisionneur. Et c'est tout ce
que Unity Physics a vraiment besoin de faire pour cette chaise, c'est la faire tomber.

Vous pouvez faire la même chose pour la table, assurez-vous d'appliquer tous ces prefab afin que les
autres objets similaires aient également les corps rigides.

2
Pour l'instant nous allons supprimer les corps rigides car nous souhaitons placer les meubles très
précisément et peut-être même sous les tables. (vous ne pouvez pas placer une chaise sous une table
car les collisionneurs se chevaucheront et les ‘rigid bodies’ entreront en conflit, et ils essaieront de
se repousser).

Donc, nous allons supprimer les corps rigides, mais il est très important que nous gardions les
collisionneurs afin que nous puissions réellement détecter ces objets à l'aide d'un Gaze system.

Introduction au système de regard (Introduction to Gaze Systems)


• Comprendre le système du regard (Gaze system)

Un système de regard est utilisé pour interagir avec différents objets. Pour comprendre le concept
d'un système de regard, vous pouvez voir la démo de Google VR. Donc, si vous commencez à jouer,
vous remarquerez qu’il y a un petit réticule au centre de l'écran qui détermine ce que vous regardez.

Ce réticule s'agrandit pour montrer que vous regardez quelque chose avec lequel vous pouvez
interagir.

3
Et dans ce cas, lorsque vous clique, le cube disparaîtra et apparaîtra ailleurs.

• Créer un réticule (reticle)


o Créez une sphère (GameObject > 3D Object > sphere) et
o Placez la sous la caméra de votre scène, qui est dans notre cas sous le Player. Cela garantit
que le réticule suit toujours la caméra.
o Assurez-vous qu'elle est à la position 0, 0, 0 sous la caméra comme un bon point de départ.
o Réduisez la taille de la sphère.
o Vous pouvez utiliser l'émulateur GVR Editor, en cliquant sur Player, pour voir le
comportement de la sphère dans la scène.

Pour que le réticule ne traverse pas les murs quand vous regardez la salle :

o Dans le dossier Assets, clic droite-Creat-Material. Nommez le ReticulMaterial


o Dans l’options shader de ReticulMaterial dans Inspector, selectionnez GoogleVR-Reticle
o Faite glisser ReticulMaterial (dans le dossier Assets) sur Sphere (dans l’hierarchie).

4
Et maintenant vous pouvez voir la sphère d'apparence blanche, dans votre scène, qui va être utilisée
comme votre réticule.

• Implémenter un raycast

Maintenant que vous avez votre réticule, vous pouvez commencer à implémenter un système de
regard et vous allez créer un script pour cela.

Pour créer un script C# : clic droit dans Assets- Creat - C# script. Nommez le GazSystem. Si vous êtes
sur une machine Windows, cela va ouvrir Visual Studio. Si vous utilisez un Mac, ce sera MonoDevelop.

Vous remarquerez qu'il commence par une méthode Start, Update. Désormais, la méthode Start
s'exécute une fois au début de la scène et la méthode Update exécute dans chaque cadre(frame) de
votre jeu.

Pour le moment vous aurez besoin d'une méthode qui traite votre regard : ProcessGaze.
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class GazeSystem : MonoBehaviour {


// Use this for initialization
void Start () {

5
}

// Update is called once per frame


void Update () {

public void ProcessGaze()


{

Ray raycastRay = new Ray(transform.position, transform.forward);


RaycastHit hitInfo;

Debug.DrawRay(raycastRay.origin, raycastRay.direction * 100);

if (Physics.Raycast(raycastRay, out hitInfo))


{
// Do something to the object
}
}
}

RaycastRay est de type Ray, integré dans Unity, utilisé pour regarder en avant.

La variable hitInfo de type RaycastHit stock les informations de l’objet touchée par le regard.

Unity a une fonction Raycast intégrée, c'est Physics.Raycast, qui retournera s'il touche réellement
quelque chose.

A l'intérieur de l’instruction if, si Raycast frappe un objet alors est ce que vous voulez interagir avec
cet objet.

Unity est livré avec un débogueur intégré pour Ray, qui permet de savoir où va votre Ray et qu’est ce
qu'il regarde. C’est la méthode Debug.DrawRay.

Enfin, la méthode ProcessGaze est appelée dans la fonction Update pour qu’elle s’exécute à chaque
cadre (frame) du jeu.
void Update () {

ProcessGaze();

Maintenant, revenez à Unity dans votre application. La première chose que vous devez faire est de
glisser le script sur votre caméra principale.

Rappelez-vous que dans le script, nous avons utilisé transform.position et transform.forward Cela doit
être la position de départ de la caméra et la direction vers l'avant de la caméra.

6
Et vous pouvez maintenant remarquer, dans ‘Inspector’, que votre système de regard est maintenant
un composant de la caméra.

Enfin, appuyez sur le bouton Player. Vous pouvez voir qu'il y a maintenant cette longue ligne blanche
très droite qui traverse directement le réticule. C'est la fonction Debug.DrawRay qui fait cela.

Et vous pouvez remarquer que Ray s'aligne parfaitement avec le réticule, et passe par le centre du
réticule et cela signifie que votre réticule va vous aider à déterminer ce que vous regardez.

7
Donc, jusqu'ici vous avez créé un Ray qui va en avant pour vous aider à regarder les choses dans votre
scène.
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class GazeSystem : MonoBehaviour {


// Use this for initialization
void Start () {

SetReticleColor(inactiveReticleColor);

// Update is called once per frame


void Update () {

ProcessGaze();

public void ProcessGaze()


{

Ray raycastRay = new Ray(transform.position, transform.forward);


RaycastHit hitInfo;

Debug.DrawRay(raycastRay.origin, raycastRay.direction * 100);

if (Physics.Raycast(raycastRay, out hitInfo))


{
// Do something to the object
}
}
}

Création d’un système de regard (Creating a Gaze System)


• Identifier les méthodes nécessaires pour le système de regard
• Décrire les étapes du système de regard

8
Dans la démo de Google VR, la première étape était que lorsque Vous regardez quelque chose, le
réticule change de couleur. Dans ce cas, vous aurez besoin d'une méthode qui définit votre réticule
sur une couleur différente : SetReticleColor.

Vous aurez aussi besoin d'une méthode qui vérifie les entrées : CheckForInput (pour agir sur l’objet
par un clic ou une pression sur le cardboard, par exemple.). Et cela se fait en trois étapes.

Check for down : la vérification du moment de l'entrée, quand elle est pressée pour la première fois
dans un frame.

Check for hold : savoir si bouton est maintenu enfoncé dans ce frame.

Check for release : pour connaître quand le bouton de la souris ou le bouton est relâché.

Maintenant, pour affiner la fonction Raycast actuelle à ce que vous allez faire, cela se fera
principalement en trois étapes :

9
La première étape est de vérifier et de s'assurer que l’objet est interactif, dans ce cas le Raycast
retournera true.

La deuxième étape est de vérifier si c'est la première fois que vous regardez cet objet.

Et puis enfin, vous devez définir l'étape de couleur du réticule.

Maintenant, nous avons le squelette de ce que notre système Gaze devrait faire.

GazeSystem
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class GazeSystem : MonoBehaviour {

// Use this for initialization


void Start () {

SetReticleColor(inactiveReticleColor);

// Update is called once per frame


void Update () {

ProcessGaze();
}

public void ProcessGaze()


{

Ray raycastRay = new Ray(transform.position, transform.forward);


RaycastHit hitInfo;

Debug.DrawRay(raycastRay.origin, raycastRay.direction * 100);

if (Physics.Raycast(raycastRay, out hitInfo))


{
// Do something to the object

// Check if the object is interactable

// Check if the object is a new object (first time looking)

// Set the reticle color


}
}

private void SetReticleColor(Color reticleColor)

10
{
// Set the color of the reticle
}

Rendre les objets observables (Making Objects Gazeable)

• Faire réagir les objets à l'interaction du regard (Make objects respond to Gaze interaction)

Dans cette partie vous allez créer un script spécifiquement pour les objets avec lesquels vous pouvez
interagir : GazeableObject.

Supprimez les méthodes Start et Update car vous n’en aurez pas besoin pour l'instant.

On veut savoir quand l'utilisateur commence à regarder un objet pour la première fois, quand il
continue à le regarder ou quand il arrête de la regarder.

Pour l'instant, vous n'allez pas implémenter ces méthodes. Vous allez juste avoir des messages de
journal (log messages) pour vous faire savoir qu'ils fonctionnent. Dans ce cas, Debug.Log. Ces
méthodes prennent en compte les informations Raycast.

Notez que dans OnGazeExit, on ne peut pas avoir d'informations RaycastHit, car Lorsque l'utilisateur
détourne le regard, il n'y a plus d'informations Raycast à transmettre.

Le mot-clé virtuel signifie que cette méthode peut être redéfinie par un enfant (child).

11
Ce sont donc toutes les actions du regard, mais maintenant vous devez penser à l’interrupteur de
cardboard (cardboard switch), ou au clic de la souris.C'est exactement le même concept et vous pouvez
remplir les méthodes : OnPress, OnHold et OnRelease.

Donc pour l'instant, c'est tout ce dont vous avez besoin pour une classe GazeableObject.

Vous allez terminer le script GazeSystem.


GazeableObject

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class GazeableObject : MonoBehaviour {

public virtual void OnGazeEnter(RaycastHit hitInfo){


Debug.Log("Gaze entered on " + gameObject.name);
}

public virtual void OnGaze(RaycastHit hitInfo){


Debug.Log("Gaze hold on " + gameObject.name);

public virtual void OnGazeExit(){


Debug.Log("Gaze exited on " + gameObject.name);
}

public virtual void OnPress(RaycastHit hitInfo){

public virtual void OnHold(RaycastHit hitInfo){

public virtual void OnRelease(RaycastHit hitInfo){

}
}

12
Connecter le système avec GazeableObjects
Donc, nous avons les deux classes GazeSystem.cs et GazeableObject.cs, sur lesquelles le système de
regard devrait agir.

Premièrement, on veut que le réticule change lorsque on regarde l'objet avec lequel on veut interagir :

o La variable GameObject est une variable publique, qui va apparaître dans l'inspector à
l'intérieur de Unity, dans laquelle vous pouvez faire glisser le réticule.
o La couleur du réticule inactive est gris, et la couleur active étant vert.

Ensuite, vous allez écrire la fonction qui va changer la couleur du réticule

13
Maintenant, lorsque le jeu démarre, on veut s’assurer que le réticule est dans son état inactif.

Maintenant, vous allez utiliser le script GaeableObject comme type pour votre objet Gaze actuel
currentGazeObject.

ClearcurrentObject() permet d’effacer l’objet Gaze actuel lorsqu’on détourne le regard. C'est donc une
fonction importante qui sera utiliser plusieurs fois tout au long du raycast.

14
Maintenant, revenez à Raycast et complétez votre code pour faire interagir le raycast avec l'objet.

Les étapes de ce processus à vérifier :

o S'assurer que l'objet que vous regardez est un objet interactif ou un objet Gazeable. hitInfo
stocke le collisionneur de l'objet du jeu que le raycast a touché. Et c'est pourquoi les objets
du jeu doivent avoir des collisionneurs.

15
o S’assurer que c'est un objet Gazeable. Dans ce cas, vous allez essayer d'obtenir le
composant objet Gazeable à partir de cet objet.

o Si GazeOBJ n'est pas nul. Il s'agit d'un objet Gazeable.

o Si vous regardez déjà cet objet dans le frame précédent, alors vous allez appeler OnGaze
sur cet objet, ce qui signifie que vous continuez à regarder le même objet. Donc le réticule
doit avoir la bonne couleur.

16
o Examinons les cas else pour toutes ces instructions if que nous avons. Si GazeOBJ est nul,
cela signifie que l’objet existe (dans le raycast), mais il n'a pas le composant d'objet
Gazeable. Nous l'effacerons parce que nous ne regardons plus un objet Gazeable.

Si le raycast physique échoue complètement, ce qui signifie que nous ne regardons rien, alors, encore
une fois, nous devons nous assurer que nous effaçons l'objet actuel.

17
Donc, pour récapituler nous vérifions le raycast touche un objet. Sinon, nous effaçons l’objet courant
parce que notre méthode ClearCurrentObject vérifie s'il y a un objet courant.

Ensuite, s'il touche un objet, nous vérifions si c’est un objet Gazeable. Si ce n'est pas le cas, encore
une fois, nous effaçons l'objet courant. Nous ne regardons plus un objet Gazeable. S'il s'agit d'un objet
Gazeable, nous vérifions si nous l'avons déjà regardé. Si nous l'avons déjà regardé, tout ce que nous
avons à faire est d'appeler OnGaze car nous continuons à regarder cet objet.

Enfin, s'il s'agit d'un nouvel objet Gazeable que nous regardons, effacez l'objet actuel car nous
regardons un nouveau, appelez OnGazeEnter sur ce nouvel objet, et enfin définissez la couleur du
réticule ainsi que nous pouvons réellement voir une réponse visuelle.

Dans la suite, nous allons terminer la saisie, puis tester notre système de regard (Gaze system) pour
nous assurer qu'il fonctionne.

GazeSystem
using System.Collections;
using System.Collections.Generic;

18
using UnityEngine;

public class GazeSystem : MonoBehaviour {

public GameObject reticle;

public Color inactiveReticleColor = Color.gray;


public Color activeReticleColor = Color.green;

private GazeableObject currentGazeObject;


private GazeableObject currentSelectedObject;

// Use this for initialization


void Start () {
SetReticleColor (inactiveReticleColor);
}

// Update is called once per frame


void Update () {
ProcessGaze ();
CheckForInput(lastHit);
}

public void ProcessGaze(){


Ray raycastRay = new Ray (transform.position, transform.forward);
RaycastHit hitInfo;

Debug.DrawRay (raycastRay.origin, raycastRay.direction * 100);

if(Physics.Raycast(raycastRay, out hitInfo)){


// Do something to the object

// Check if the object is interactable

// Get the GameObject from the hitInfo


GameObject hitObj = hitInfo.collider.gameObject;

// Get the GazeableObject from the hit Object


GazeableOjbect gazeObj = hitObj.GetComponent<GazeableObject> ();

// Object has a GazeableObject componenet


if (gazeObj != null) {

// Object we're looking at is different


if (gazeObj != currentGazeObject) {
ClearCurrentObject ();
currentGazeObject = gazeObj;
currentGazeObject.OnGazeEnter (hitInfo);
SetReticleColor (activeReticleColor);

} else {
currentGazeObject.OnGaze (hitInfo);
}
} else {
ClearCurrentObject ();
}
}
}

private void SetReticleColor(Color reticleColor){


// Set the color of the reticle
reticle.GetComponent<Renderer>().material.SetColor("_Color", reticleColor);
}

19
private void CheckforInput(RaycastHit hitinfo){

// Check for down

// Check for hold

// Check for release


}

private void ClearCurrentObject(){


if(currentGazeObject != null){
currentGazeObject.OnGazeExit();
SetReticleColor(inavticeReticleColor);
currentGazeObject = null;
}
}
}

GazeableObject
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class GazeableObject : MonoBehaviour {

public virtual void OnGazeEnter(RaycastHit hitInfo){


Debug.Log("Gaze entered on " + gameObject.name);
}

public virtual void OnGaze(RaycastHit hitInfo){


Debug.Log("Gaze hold on " + gameObject.name);

public virtual void OnGazeExit(){


Debug.Log("Gaze exited on " + gameObject.name);
}

public virtual void OnPress(RaycastHit hitInfo){


Debug.Log("Button pressed");
}

public virtual void OnHold(RaycastHit hitInfo){


Debug.Log("Button hold");
}

public virtual void OnRelease(RaycastHit hitInfo){


Debug.Log("Button released");
}
}

Vérification de l'entrée (Checking for Input)


Nous allons terminer notre système de regard en vérifiant les entrées, comme les clics de souris et
les pressions sur les boutons, puis en testant le système de regard avec certains objets à l'intérieur
de Unity.

Pour le moment, la seule méthode qu'il nous reste à remplir est CheckForInput.

20
Notez que dans la classe GazeableObject.cs, nous avons terminé et traité OnGazeEnter, OnGaze, il
nous reste maintenant OnPress, OnHold et OnRelease.

Vous allez créer un autre objet gazeable : currentSelectedObject, pour garder une trace de l'objet sur
lequel vous avez appuyé sur le bouton.

21
Dans la méthode CheckForInput. Nous devons d'abord vérifier qu'il y a un type d'entrée (appuie vers
le bas), et ensuite, nous devons nous assurer que nous regardons actuellement un objet. Nous
pouvons configurer une instruction if pour commencer.

C'est juste if Input.GetMouseButtonDown et s'il y a un currentGazeObject actif.

Unity traite GetMouseButtonDown de la même manière pour une souris réelle ou même pour Google
Cardboard. Zéro serait un clic gauche de la souris, et pour Google Cardboard, avec un seul bouton, le
clic sur le carton ou le casque que vous avez qui a un bouton.

Si nous avons à la fois une pression et que le currentGazeObject n'est pas nul ? Il y a en fait deux
choses que nous devons faire. Tout d'abord, nous devons nous assurer que nous stockons notre
currentSelectedObject dans le currentGazeObject. Nous regardons un (gaze object), nous appuyont ;
C'est maintenant notre currentSelectedObject. Et ensuite, avec ce currentSelectedObject, nous
pouvons appeler la méthode OnPress que nous avons configurée dans GazeableObject.

22
Si le bouton est maintenu et s'il y a un currentSelectedObject, dans ce cas nous appelons OnHold pour
cet objet.

Enfin, nous devons vérifier la libération. Nous allons utiliser Input.GetMouseButtonUp pour vérifier
quand nous relâchons l'option. Alors, nous avons Input.GetMouseButtonUp, et il y a un
currentSelectedObject, nous appelons d'abord OnRelease sur l'objet, lui faisant savoir que nous
avons relâché le bouton, puis nous définissons le currentSelectedObject sur null.

Si nous ne regardons plus l'objet, nous n'avons plus le Raycast hitInfo dont OnHold et OnRelease ont
besoin, nous devons utiliser le dernier hitInfo Raycast réussi que nous avons.

Alors, nous créons une variable privée RaycastHit que nous appelons lastHit.

23
Maintenant, chaque fois que le raycast touche quelque chose, c'est notre dernier (successful hit)
succès.

Donc, nous allons à notre raycast, le dernier endroit où le raycast est réussi et nous mettrons lastHit
égal à hitInfo juste après la fin du raycast.

Alors maintenant nous avons le dernier hit réussi.

24
Maintenant, nous allons ajouter CheckForInput juste après ProcessGaze dans la méthode Update, et
ça va utiliser la dernière valeur de hit que nous avions.

Notez que nous n'allons jamais rencontrer le problème où RaycastHit est nul ou n'est pas réussi ou
ce n'est pas réellement une valeur car si nous regardons notre fonction CheckForInput, le
currentSelectedObject ne fonctionnera que si notre currentGazeObject existe, et notre
currentGazeObject n'existera que si un raycast a réussi au moins une fois, ce qui signifie que cette
valeur lastHit doit toujours être définie sur quelque chose de réussi. Nous ne rencontrerons donc
jamais de problèmes nuls ou de valeurs non valides.

Nous allons donc revenir à Unity, et nous voyons que nous avons nos deux scripts.

Maintenant, vous pouvez choisir la couleur du réticule.

25
Si vous souhaitez que la couleur du réticule actif soit bleue, vous pouvez simplement cliquer dessus et
la rendre bleue.

Enfin, vous devez faire glisser votre réticule vers ce champ de réticule. Dans ce cas, votre sphère est
votre réticule, et vous pourriez le renommer ‘Réticule’.

Le raycast, diffusé depuis la caméra, semble toujours frapper le réticule. Vous devez donc s’assurer
que votre réticule ignore le raycast à tout moment.

26
Mais maintenant, nous n'avons aucun objet interactif réel dans la scène, aucun objet observable.
Donc rien ne va encore se passer.

Alors vous pouvez cliquer sur un objet (chaise) et y ajouter votre script GazeableObject (Ou bien faire
glisser GazeableObject).

Maintenant dès que je regarde la chaise, mon réticule devient bleu, confirmant que nous regardons
un objet observable en ce moment.

Et ce qui est intéressant, c'est que vous avez un tas d'instructions d'impression de débogage si vous
cliquez sur la console.

27
Nous venons de construire un système de regard complet qui fonctionne et interagit avec ces objets
comme nous le souhaitons, et si nous appliquons le prefab sur la chaise, alors toutes les chaises
seront des objets observables.

28
Ainsi, je peux regarder autour de moi et chacune de ces chaises mettra en évidence mon réticule,
j'obtiendrai mes déclarations d'impression, confirmant que toutes mes fonctions de regard
fonctionnent sur ces objets.

Et maintenant, nous allons avoir un problème avec notre lampe. Si vous ajoutez le script
GazeableObject à la lampe et si vous la survolez, vous remarquez que rien n’est sélectionné et que
vous ne pouvez rien faire.

Notez que vous avez plaçons le script GazeableObject au-dessus sur le parent de la lampe.

Mais rappelez-vous que la façon dont nous obtenons des objets observables utilise un raycast frappant
un collisionneur, et si nous nous souvenons, le collisionneur est sur l'enfant sous la lampe 1, c'est là
que se trouve notre collisionneur.

29
Donc, en d'autres termes, notre raycast frappe l'enfant de la lampe. Et on remarque qu'il n'a pas de
composant GazeableObject.

Maintenant, il existe une solution assez rapide pour cela. Vous pouvez simplement utiliser une version
modifiée de GetComponent appelée GetComponentInParent.

GetComponentInParent vérifiera tous les objets parents pour les composants correspondants, y
compris l'actuel.

30
Le raycast va frapper l’enfant da la lampe, et ensuite il cherchera GazeableObject sur le parent de
lampe. Donc il reconnaîtra également cet objet comme un objet regardable,

Vous avez donc construit un système de regard complet qui peut interagir avec tous ces différents
objets de la scène, il peut reconnaître les entrées d’eux, et ultérieurement, vous pouvez réellement
utiliser ce type d'interaction pour faire en sorte que les meubles fassent des choses différentes et
interagissent avec le monde qui vous entoure.

GazeSystem
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class GazeSystem : MonoBehaviour {

public GameObject reticle;

public Color inactiveReticleColor = Color.gray;


public Color activeReticleColor = Color.green;

private GazeableObject currentGazeObject;


private GazeableObject currentSelectedObject;

// Use this for initialization


void Start () {
SetReticleColor (inactiveReticleColor);
}

// Update is called once per frame


void Update () {
ProcessGaze ();
CheckForInput(lastHit);
}

public void ProcessGaze(){


Ray raycastRay = new Ray (transform.position, transform.forward);
RaycastHit hitInfo;

31
Debug.DrawRay (raycastRay.origin, raycastRay.direction * 100);

if(Physics.Raycast(raycastRay, out hitInfo)){


// Do something to the object

// Check if the object is interactable

// Get the GameObject from the hitInfo


GameObject hitObj = hitInfo.collider.gameObject;

// Get the GazeableObject from the hit Object


GazeableOjbect gazeObj = hitObj.GetComponent<GazeableObject> ();

// Object has a GazeableObject componenet


if (gazeObj != null) {

// Object we're looking at is different


if (gazeObj != currentGazeObject) {
ClearCurrentObject ();
currentGazeObject = gazeObj;
currentGazeObject.OnGazeEnter (hitInfo);
SetReticleColor (activeReticleColor);

} else {
currentGazeObject.OnGaze (hitInfo);
}
} else {
ClearCurrentObject ();
}
}
}

private void SetReticleColor(Color reticleColor){


// Set the color of the reticle
reticle.GetComponent<Renderer>().material.SetColor("_Color",
reticleColor);
}

private void CheckforInput(RaycastHit hitinfo){

// Check for down

// Check for hold

// Check for release


}

private void ClearCurrentObject(){


if(currentGazeObject != null){
currentGazeObject.OnGazeExit();
SetReticleColor(inavticeReticleColor);
currentGazeObject = null;
}
}
}

32

Vous aimerez peut-être aussi