The Xna-Way: Tutorial 6: Orientare oggetto nella direzione in cui si muove e telecamera che lo insegue

Questa volta il compito che mi sono proposto è stato un po' più difficile:
avendo creato un decente MeteorManager questa volta volevo muovermi attraverso questo fitto campo di meteoriti con una navicella spaziale.

Sono partito col pensare a ciò:
- per ora non mi interessa calcolare le collisioni con i meteoriti
- la telecamera sarà in 3° persona, quindi ci troveremo alle spalle della nostra astronave (altrimenti avevamo già la telecamera in prima persona per muoverci)
- la telecamera dovrà seguire il nostro vascello spaziale
- dovremo far muovere nello spazio il nostro mezzo di trasporto

tutto questo ci porta a dover modificare la nostra telecamera per implementare "l'inseguimento" della nostra astronave. Avremo quella che chiamo Follow Camera.
Anche per il nostro vascello avremo il nostro bel da fare: non dovremmo solo farlo muovere e ruotare nel mondo 3D, ma dovremo farlo muovere nella direzione in cui "guarda", quindi movimenti e rotazioni dovranno essere fatti in modo particolare lavorando sulle direzioni, cosa un po' complicata e astrusa ma fattibile.

Per prima cosa è meglio fare la modifica alla classe Camera in modo da implementare l'inseguimento di un determinato bersaglio. In questo modo quando poi andremo a far muovere il nostro oggetto nello spazio la telecamera gli starà dietro e noi non avremo problemi ad osservarlo ^_^

Preso il progetto dell'ultimo post, andiamo nella classe Camesa.cs e sotto il metodo UpdateFreeCamera() andiamo a mettere il seguente metodo:

       private void updateFollowCamera(GameTime gameTime)
       {
           float delta = (float)gameTime.ElapsedGameTime.TotalSeconds;
           //creo la matrice temporanea
           Matrix tmp = Matrix.Identity;
           //imposto la direzione di osservazione, la direzione dell'alto e la direzione della destra
           tmp.Forward = direction;
           tmp.Up = up;
           tmp.Right = Vector3.Cross(up, direction); //questa è calcolata come prodotto tra due vettori

           Vector3 t;
           //trasformo la distanza (offset) dal punto di osservazione con la matrice calcolata
           Vector3.Transform(ref offset, ref tmp, out t);

           Vector3 positionTmp;
           //calcolo la posizione che vogliamo far avere alla nostra telecamera sommando al punto che siamo osservando
           //la posizione trasformata lungo la matrice
           Vector3.Add(ref target, ref t, out positionTmp);
           //aggiorno la posizione finale
           position = positionTmp;
       }

Per non avere errori dovremo aggiungere le seguenti variabili di classe:

       //variabili per l'inseguimento del target
       protected Vector3 offset = Vector3.Zero;
       protected Vector3 direction = Vector3.Forward

Cosa fa il metodo?
Il metodo crea una matrice identità e ne imposta i valori per le direzioni che rappresentano il davanti, l'alto e la destra.
Direction e up da dove vengono? Sono dati e assegnati tramite l'oggetto che vogliamo inseguire: cioè direction rappresenta la direzione in cui si sta muoveno il nostro oggetto, mentre up è la direzione che il nostro bersaglio considera come l'alto. In questo modo potremmo mantenere costati le rotazioni!
La destra viene calcolata come prodotto tra i due vettori.

Dopo trasformo l'offest usando la matrice, e sommo questo offest alla posizione del punto osservato e assegno il risultato alla posizione.

Quello che manca da fare ora è la classe per gestire la nostra navicella spaziale.
Ecco il file Ship.cs, comunque presente nell'archivio allegato:
Ship.cs Show/Hide

   public class Ship : Microsoft.Xna.Framework.GameComponent
   {
       Model myModel;
       Matrix world;
       InputI inputDevice;
       CameraI myCamera;

       //Dati per il rendering
       Texture2D text;   

       Effect currentEffect = null;
       public Effect CurrentEffect
       {
           get { return currentEffect; }
           set { currentEffect = value; }
       }

       //Dati per le trasformazioni
       Vector3 position = Vector3.Zero;
       public Vector3 Position
       {
           get { return position; }
           set { position = value; }
       }

       float scale = 1.0f;
       public float Scale
       {
           get { return scale; }
           set { scale = value; }
       }

       //Dati per l'orientamento verso la direzione di movimento
       Vector3 destra = Vector3.Right;
       Vector3 up = Vector3.Up;
       public Vector3 Up
       { get { return up; } }

       Vector3 direction = Vector3.Forward;
       public Vector3 Direction
       { get { return direction; } }

       float pitch, yaw;
       float val;
       Vector3 velocità;

       public Ship(Game game, string myModel, string texture, Effect effect)
           : base(game)
       {
           this.myModel = Game.Content.Load<Model>(myModel);
           this.text = Game.Content.Load<Texture2D>(texture);
           myCamera = (CameraI)game.Services.GetService(typeof(CameraI));
           inputDevice = (InputI)game.Services.GetService(typeof(InputI));
           currentEffect = effect;

           foreach (ModelMesh mesh in this.myModel.Meshes)
               foreach (ModelMeshPart mp in mesh.MeshParts)
                   mp.Effect = currentEffect;
       }

       public override void Initialize()
       {
           base.Initialize();
       }

       public override void Update(GameTime gameTime)
       {
           float elaps = (float)gameTime.ElapsedRealTime.TotalSeconds;
           yaw = 0;
           pitch = 0;
           val = 0;
           if (inputDevice.actualKeyboardState.IsKeyDown(Keys.Space))
               val = 1.0f;
           if (inputDevice.actualKeyboardState.IsKeyDown(Keys.Right))
               yaw -= 3f * elaps;
           if (inputDevice.actualKeyboardState.IsKeyDown(Keys.Left))
               yaw += 3f * elaps;
           if (inputDevice.actualKeyboardState.IsKeyDown(Keys.Up))
               pitch -= 3f * elaps;
           if (inputDevice.actualKeyboardState.IsKeyDown(Keys.Down))
               pitch += 3f * elaps;
           if (inputDevice.actualKeyboardState.IsKeyDown(Keys.R))
           {
               yaw = 0.0f;
               pitch = 0.0f;
               direction = Vector3.Forward;
               up = Vector3.Up;
               destra = Vector3.Right;
               position = Vector3.Zero;
           }

           //se l'astronave a testa in giù devo invertire il valore di yaw
           if (up.Y < 0)
               yaw = -yaw;

           //calcolo la matrice di rotazione data dagli angoli yaw e pitch
           Matrix rotationMatrix = Matrix.CreateFromAxisAngle(destra, pitch) *
               Matrix.CreateRotationY(yaw);

           //trasformo la direzione e l'alto con la matrice calcolata
           Vector3.TransformNormal(ref direction, ref rotationMatrix, out direction);
           Vector3.TransformNormal(ref up, ref rotationMatrix, out up);

           //normalizzo
           direction.Normalize();
           up.Normalize();

           //calcolo i vettori destra e up come prodotto tra vettori
           Vector3.Cross(ref direction, ref up, out destra);
           Vector3.Cross(ref destra, ref direction, out up);

           //calcolo la forza, l'accellerazione e la velocità
           Vector3 forza = direction * val * 2400000;
           Vector3 accellerazione = forza / 2 ;
           velocità = accellerazione * elaps;
           /*
            //ricorda di diminuire il fatto moltiplicativo nel cacolo della forza
            velocità += accellerazione * elaps;

            //per farlo fermare nel caso si usasse il secondo metodo
            velocità *= 0.97f;*/

           position += velocità * elaps;

           //----------------------------------
           world = Matrix.Identity;

           world.Forward = direction;
           world.Up = up;
           world.Right = destra;

           world *= Matrix.CreateScale(scale);
           world *= Matrix.CreateTranslation(position);
          
           base.Update(gameTime);
       }

       public void Draw(GameTime gameTime)
       {
           currentEffect.Parameters["Color"].SetValue(Color.White.ToVector4());
           currentEffect.Parameters["Projection"].SetValue(myCamera.Projection);
           currentEffect.Parameters["View"].SetValue(myCamera.View);
           currentEffect.Parameters["ColorMap"].SetValue(text);
           currentEffect.Parameters["World"].SetValue(world);
           foreach (ModelMesh mesh in myModel.Meshes)
               mesh.Draw();
       }
   }

Il file va inserito nel progetto Meteor e non nella libreria, dato che, come il MeteorManager, questo oggetto è specifico per questa applicazione.

Il pezzo saliente è il metodo Update, il resto è roba già vista!
Cosa fa questo benedetto metodo?
Prima di tutto riazzera il valore della rotazione per yaw e pitch, e anche val.
Val indica se la barra spaziatrice è premuta o meno, e quindi se dobbiamo muoverci o no.
Con la pressione delle frecce direzionali imposto i valori per le rotazioni, e con R riporto il tutto allo stato iniziale.

Con

if (up.Y < 0)
    yaw = -yaw;

faccio in modo che se mi trovo a testa in giù e premo verso destra, continuo a girare ancora verso destra non verso sinitra.

Dopo di chè calcolola matrice di rotazione (nota: l'angolo per pitch è calcolato passando l'asse di rotazione), e uso tale matrice per trasformare la direzione e l'up.

Ho poi il calcolo della forza applicata all'oggeto.
Sono formule fisiche. Forza = massa * accellerazione.
So che la formula per calcolare la velocità è sbagliata (anche se quella giusta è riportata come commentata). Ma ora come ora non mi interessa la correttezza delle fisica.

Alla fine poi ho la creazione della world matrix per la nostra navicella, fatta in modo molto simile a come abbiamo costruito quella per la telecamera.

Cosa manca da fare per far funzionare il tutto?
Aggiungere il file per il modello 3D e la texture al progetto, creare la nostra astronave, aggiungerla ai components e disegnarla.
Poi dobbiamo modificare leggermente le impostazioni della telecamera.

Cominciamo: nel costruttore di Game1.cs modifichiamo il codice per la telecamera come segue

           myCamera = new Camera(this);
           myCamera.FarPlane = 100000;
           myCamera.Offset = new Vector3(0, 100, 500);
           myCamera.Mode = CameraMode.Follow;
           Components.Add(myCamera);

Impostiamo la distanza dal punto di osservazione e cambiamo il tipo di telecamera.

Nel metodo LoadContent() aggiungiamo questo:

           myShip = new Ship(this, @"Models\p2_wedge", @"Textures\wedge_p2_diff_v1", defaultEffect);
           myShip.Scale = 0.1f;
           Components.Add(myShip);

Dove myShip è l'oggetto per la nostra astronave, che dobbiamo aver definito nella classe. Lo scalo ad un fattore 0.1 perchè altrimenti sarebbe troppo grande.

Nel metodo Draw dopo il render per il meteorManager aggiungiamo questo:
myShip.Draw(gameTime);

E nel metodo Update questo:

           if (myCamera.Mode == CameraMode.Follow)
           {
               myCamera.Target = myShip.Position;
               myCamera.Up = myShip.Up;
               myCamera.Direction = myShip.Direction;
           }

In modo che se la telecamera è di tipo follow, si aggiorna il suo target alla posizione della nostra navicella (ma potrebbe essere benissimo qualsiasi cosa!), e settiamo up e direction con i valori provenienti dal nostro oggetto myShip.

Dovrebbe essere tutto! :D
Se qualcosa non va c'è sempre il file allegato!
E se trovate qualche errore fatemelo notare così correggo ^__^

XNA-tut6.rar

Argomenti trattati:
> muovere un oggetto lungo la direzione che sta osservando
> telecamera che insegue il nostro oggetto

Alla prossima!