domanda su XNA (c#)

[Toty_]

Nessuno sa cosa fa il metodo Vector3.Transform(Vector3 a, Matrix b) ?

[Cherno]

moltiplicazione vettore matrice. Se cerchi su google le operazioni delle matrici, ti spiegano bene i vari passaggi.

[Toty_]

E' impossibile moltiplicare un Vector3 per una Matrix!

Un Vector3 è una matrice 1x3 mentre la Matrix è una 4x4, due matrici possono moltiplicarsi solo se la prima ha tante colonne quante sono le righe delle seconda (quindi una 1x3 non può moltiplicare una 4x4 e viceversa!!!)

Ma allora cos'è questo Vector3.Transform?

Mi basterebbe sapere questo per capirci un po' di più.
Conosco le operazioni e le regole sulle matrici e, ultimamente, ho anche studiato come creare matrici di trasformazione, ma in un esempio ho trovato questo metodo che nessuno sa dirmi cos'è.

[Cherno]

i vector3 sono sempre considerati a 4 componenti, dove la w dovrebbe essere ad 1.

Aggiungo: http://social.msdn.microsoft.com/For...a-4e8b3e5492af

[Toty_]

i vector3 sono sempre considerati a 4 componenti, dove la w dovrebbe essere ad 1.

Allora come mai il compilatore mi segnala errore se tento di moltiplicare un Vector3 per una Matrix?
Se fosse come dici tu, la moltiplicazione dovrebbe essere lecita.

[Cherno]

Al compilatore non gliene frega un ***** delle regole della matematica, probabilmente sbagli a passargli qualcosa alla funzione transform, oppure l'oggetto che la utilizza non è valido.

[Toty_]

Al compilatore non gliene frega un ***** delle regole della matematica, probabilmente sbagli a passargli qualcosa alla funzione transform, oppure l'oggetto che la utilizza non è valido.

Ok calmati, non c'è motivo di scaldarsi!
Allora, visto che Transform moltiplica un Vector3 per una Matrix, questo codice per muovere la telecamera cosa fa esattamente?

// Crea una matrice di rotazione secondo i vari angoli di rotazione
Matrix rot = Matrix.CreateFromYawPitchRoll(camera_rotazione, camera_beccheggio, camera_rollio);
// Calcola i vettori per la matrice di rotazione corrente.
Vector3 camUp = Vector3.Transform(Vector3.UnitY, rot); //moltiplica (0,1,0) per la matrice di rotazione rot
Vector3 camLook = Vector3.Transform(Vector3.UnitZ, rot); //moltiplica (0,0,1) per rot
Vector3 camLeft = Vector3.Cross(camUp, camLook); //equivale a (1,0,0) per rot

//...

Mie_variabili.View = Matrix.CreateLookAt(camera_posizione, camera_posizione + camLook, camUp);

E' inutile che ti inca**i, Cherno. Cosa dovrei dire io allora, visto che sono mesi che su internet trovo solo informazioni ambigue e incomplete?

[vaitrafra]

tanto per cominciare, il fatto che il compilatore ti dia un errore non vuole dire molto.
Postare il testo dell'eccezione magari ci aiuta ad aiutarti.

In secondo luogo io spero che per moltiplicare due matrici tu usi il metodo Matrix.Multiply(Matrix, Matrix) e non l'operatore di moltiplicazione liscio.

[Cherno]

Ok calmati, non c'è motivo di scaldarsi!
Allora, visto che Transform moltiplica un Vector3 per una Matrix, questo codice per muovere la telecamera cosa fa esattamente?

// Crea una matrice di rotazione secondo i vari angoli di rotazione
Matrix rot = Matrix.CreateFromYawPitchRoll(camera_rotazione, camera_beccheggio, camera_rollio);
// Calcola i vettori per la matrice di rotazione corrente.
Vector3 camUp = Vector3.Transform(Vector3.UnitY, rot); //moltiplica (0,1,0) per la matrice di rotazione rot
Vector3 camLook = Vector3.Transform(Vector3.UnitZ, rot); //moltiplica (0,0,1) per rot
Vector3 camLeft = Vector3.Cross(camUp, camLook); //equivale a (1,0,0) per rot

//...

Mie_variabili.View = Matrix.CreateLookAt(camera_posizione, camera_posizione + camLook, camUp);

E' inutile che ti inca**i, Cherno. Cosa dovrei dire io allora, visto che sono mesi che su internet trovo solo informazioni ambigue e incomplete?

Mica mi incazzo, anzi se vuoi te lo ripeto: al compilatore non gliene frega una gran ceppa delle regole della matematica.


la matrice lookAt è definita da 3 vettori: eye, look ed up.

eye indica la posizione della camera,
look indica la direzione verso la quale guarda
up indica il vettore che ci dice su quale asse sta l'asse verticale.

una volta forniti questi tre vettori, la tua camera è bella e funzionante, stai solo attento a non mettere eye e look a zero, altrimenti sfasa tutto.

Quindi tu operando sui valori di qye e look, permetti alla tua camera di girare. Ora capisco che tu sia già in difficoltà per fatti tuoi, però scrivi su google "openGL camera" e troverai informazioni più dettagliate su una cameraLookAt con un sacco di codice.

[Toty_]

Ora capisco che tu sia già in difficoltà per fatti tuoi, però scrivi su google "openGL camera" e troverai informazioni più dettagliate su una cameraLookAt con un sacco di codice.

Ok, grazie.

Cercherò su google "openGL camera" e vi farò sapere il prima possibile.

[Toty_]

So cos'è la matrice lookAt. Il problema è riuscire a far ruotare la visuale come un gioco fps.
Ho studiato molto in questi giorni (in questo periodo ho tempo da perdere) e sono riuscito a capire qualcosa sulle matrici di trasformazione.

Ora il problema è la rotazione obliqua. Credo che l'unico modo per ottenerla sia quello di moltiplicare le matrici di rotazioni di tutti e tre gli assi (proprio come fa CreateFromYawPitchRoll, se non sbaglio).

Questo è il maledetto codice (preso da un sito) che mi sta facendo impazzire da due settimane. Con queste poche righe è possibile far ruotare la visuale e spostare la telecamera:

Matrix rot = Matrix.CreateFromYawPitchRoll(camera_rotazione, camera_beccheggio, camera_rollio);
// Calcola i vettori per la matrice di rotazione corrente.
Vector3 camUp = Vector3.Transform(Vector3.UnitY, rot);
Vector3 camLook = Vector3.Transform(Vector3.UnitZ, rot);
Vector3 camLeft = Vector3.Cross(camUp, camLook);
//...
if (keyState.IsKeyDown(Keys.A))
camera_posizione += speed * elapsedSec * camLeft;
if (keyState.IsKeyDown(Keys.D))
camera_posizione -= speed * elapsedSec * camLeft;
if (keyState.IsKeyDown(Keys.W))
camera_posizione += speed * elapsedSec * camLook;
if (keyState.IsKeyDown(Keys.S))
camera_posizione -= speed * elapsedSec * camLook;
//...
Mie_variabili.View = Matrix.CreateLookAt(camera_posizione, camera_posizione + camLook, camUp);

-------------
Vi imploro di osservare un attimo questo codice e di rispondermi a due domande:

-1. ognuno dei tre vettori (camUp, ecc..) rappresenta una riga della matrice rot. Per caso, ogni riga è il punto di rotazione attorno ad un asse?
-2. nell'ultima riga di codice, perchè il punto da focalizzare è dato dalla somma tra la posizione della camera e la terza riga di rot (camLook)?

[Ronin]

guarda io di xna e di c# non so proprio niente.
però tu hai bisogno di un libro che parli di algebra matriciale e geometria, non di un tutorial di programmazione (in verità, ne avrei bisogno anche io, ma provo ad aiutarti lo stesso).

in sintesi, se poniamo che lo spazio fisico sia rappresentabile come uno spazio a 3 dimensioni, possiamo rappresentare matematicamente i cambi di vista (che corrispondono a rotazioni della terna degli assi geometrici) con delle matrici: per ruotare un sistema di riferimento da una posizione ad un altra, moltiplico la matrice degli assi (scusa se non entro nel merito di termini come versori e basi ortogonali, occorre aver studiato la materia geometria e algebra, e io non ho nemmeno ricordi tanto freschi) del primo con la matrice di rotazione, per ottenere quella del secondo

createfromyawpitchroll crea una matrice di rotazione a partire da 3 valori di rotazione angolare lungo ciascuno dei tre assi (yaw pitch e roll sono appunto i nomi inglesi di rollio, beccheggio e imbardata, termini il cui significato facilmente troverai spiegato su internet).

vector3.transform prende un vettore e lo trasforma in base alla matrice (nel caso specifico applica la matrice rot a delle coordinate, ovvero trasforma dei vettori coordinata da un sistema di riferimento ad un altro). perciò i tre vettori NON rappresentano righe della matrice rot: essendo il risultato del prodotto tra matrice di rotazione e vettore riga, il risultato è una colonna di rot, che corrisponde al versore della base originale espresso nel nuovo riferimento (ovvero, il versore del nuovo asse x-y-z a seconda della colonna che prendiamo).

unitY e unitZ sono le basi (i versori degli assi Y e Z), cioè sono i vettori (0,1,0) e (0,0,1): essi vengono convertiti negli assi del riferimento ruotato, trasformandoli con la matrice rot.

vector3.cross realizza il prodotto vettoriale tra i due vettori di cui sopra (e cioè crea il versore perpendicolare, visto che i moduli sono unitari, ovvero l'asse X del riferimento ruotato)

camera_posizione è una matrice che rappresenta la posizione della telecamera, a seconda dei tasti premuti essa viene incrementata di speed*elapsedSec (cioè dello spostamento) o lungo la direzione di camleft (=lungo l'asse X) o lungo camlook (=lungo l'asse Y). ciò corrisponde allo spostare la vista in orizzontale/verticale SENZA ruotarla.

a questo punto nell'ultima istruzione viene detto al compilatore di creare una vista in cui la camera si trova nella posizione camera_posizione (=la posizione traslata, senza rotazione), l'asse verticale è orientato in direzione camUp (l'avevo calcolato prima, infatti, è la nuova orientazione dell'asse Y) e il punto dove la telecamera punta è dato dalla somma di camera posizione e camlook.

il "bersaglio" risulta quello, quindi, perchè con camUP io imposto la rotazione dell'asse Y (imposto la direzione che per la camera è verticale), quindi mi resta solo da effettuare una seconda rotazione (quella dell'asse Z), per posizionare il "fuoco".
ma questa rotazione dell'asse Z (relativa alla nuova posizione, e che quindi parte da camera_posizione) guardacaso è data da camlook (che avevo appositamente calcolato partendo dal versore Z e ruotandolo)

[Toty_]

perciò i tre vettori NON rappresentano righe della matrice rot: essendo il risultato del prodotto tra matrice di rotazione e vettore riga, il risultato è una colonna di rot, che corrisponde al versore della base originale espresso nel nuovo riferimento (ovvero, il versore del nuovo asse x-y-z a seconda della colonna che prendiamo).

E' strano, perchè Vector3.Transform moltiplica un Vector3 per una matrix (dando l'elemento w=1 al Vector3 per poter effettuare il prodotto). Moltiplicando Vector3.UnitY e Vector3.UnitZ per rot, ottengo le righe di rot.

E comunque, CampUp non rientra nel punto focalizzato perchè quest'ultimo viene indicato come secondo parametro (e non terzo) di Matrix.CreateLookAt. Quindi, pare che il punto focalizzato tenga conto solo di camLook (camera_posizione+Camlook), come mai?

[Ronin]

sulle righe o colonne non metto la mano sul fuoco, perchè non so bene se vector3.unity/z restituiscono un vettore riga o colonna; cmq il senso è quello: righe o colonne che siano, rappresentano i versori degli assi nel riferimento ruotato (transform dovrebbe corrispondere alla moltiplicazione di rot per il vettore, e non del vettore per rot; in tal modo si dovrebbero ottenere le colonne di rot). più di tanto non posso aiutarti perchè io ragiono con le matrici 3x3 della geometria analitica, quindi non ho idea di che cosa XNA memorizzi nella quarta riga/colonna.

camup è il terzo parametro di createlookat, ma come ti ho spiegato la funzione "separa" le informazioni necessarie in due argomenti separati: richiede una direzione in cui puntare (che è camera_posizione+Camlook) e una direzione in cui orientare l'asse Y, ruotandolo intorno alla direzione precedente (che è camUP).
fai conto che prima punta il fucile verso camera_posizione+Camlook (che è dove effettivamente deve puntare), poi ruota il fucile su se stesso fino a che il mirino del fucile si trova in alto (direzione di camUP) e il grilletto in basso...

[Toty_]

sulle righe o colonne non metto la mano sul fuoco, perchè non so bene se vector3.unity/z restituiscono un vettore riga o colonna; cmq il senso è quello: righe o colonne che siano, rappresentano i versori degli assi nel riferimento ruotato (transform dovrebbe corrispondere alla moltiplicazione di rot per il vettore, e non del vettore per rot; in tal modo si dovrebbero ottenere le colonne di rot). più di tanto non posso aiutarti perchè io ragiono con le matrici 3x3 della geometria analitica, quindi non ho idea di che cosa XNA memorizzi nella quarta riga/colonna.

Scusami Ronin ma, dato che mi dici di non conoscere c#, devo metterti al corrente di alcune cose prima di continuare la discussione (molto interessante, a mio parere) che valgono per tutti quelli che stanno leggendo:

- Con XNA i Vector3 sono matrici 1x4 (e non 4x1) e le matrici Matrix sono 4x4. Quindi il prodotto (seguendo le regole sulle matrici) deve essere per forza Vector3 * Matrix e non viceversa. Quindi, Vector3.unitY * rot (ad esempio) restituirà per forza la seconda riga di rot (e non una colonna).

- La parte che mi preoccupa è il secondo parametro di Matrix.CreateLookAt: il mirino della camera. La sua rotazione, precisamente.

Il tutto sembre funzionare ma non capisco perchè. Sembra una magia senza una spiegazione.

Perchè sommiamo camera_posizione per camLook (terza riga di rot)? Che senso ha?

Infine, vorrei chiederti di usare un linguaggio un po' più comprensibile (troppo difficile per me) e di spiegarmi il significato di versore.

Aiutatemi, sono disperato. Pensavo di aver capito e invece....

[Toty_]

Nessuno vuole aiutarmi?

[Toty_]

A questo punto, mi è venuto un dubbio: Vector3 è una 1x4 o una 4x1?

[aguayo]

ehi anch'io sto cercando di studiare xna...anche se da poco
cameraDirection = Vector3.Transform(cameraDirection,Matrix.CreateFro mAxisAngle(cameraUp, (-MathHelper.PiOver4 / 180) * (Mouse.GetState().X - prevMouseState.X)));

quando sposto il mouse sull'asse x cambia direzione in cui guarda la telecamera in proporzione allo spostamento del mouse...da dove studi?cioè usi qualche libro?

[Toty_]

Ho dato meglio un'occhiata.
Pare proprio che Vector3 sia una 1x4 (e non 4x4).
Infatti, il precedente codice che ho postato...


Vector3 camUp =Vector3.Transform (Vector3.UnitY, rot);
Vector3 camLook = Vector3.Transform (Vector3.UnitZ, rot);
Vector3 camLeft = Vector3.Transform (Vector3.UnitX, rot);

... crea questi tre vettori ognuno dei quali contiene una riga della matrice rot (e non una colonna).
Infatti, questo codice può essere tranquillamente sostituito con il seguente:

Vector3 camUp = newVector3(rot.M21,rot.M22,rot.M23);
Vector3 camLook = newVector3(rot.M31,rot.M32,rot.M33);
Vector3 camLeft = newVector3(rot.M11,rot.M12,rot.M13);

Non capisco perchè questi vettori debbano contenere le righe e non le colonne di rot (le colonne avrebbero rappresentato le coordinate del punto ruotato).

Questo codice serve per ruotare la visuale (e spostare la telecamera) della camera:

Matrix rot = Matrix.CreateFromYawPitchRoll(camera_rotazione, camera_beccheggio, camera_rollio);
//...
Vector3 camUp = newVector3(rot.M21,rot.M22,rot.M23);
Vector3 camLook = newVector3(rot.M31,rot.M32,rot.M33);
Vector3 camLeft = newVector3(rot.M11,rot.M12,rot.M13);

//... da qui, per spostare la telecamera
if (keyState.IsKeyDown(Keys.A))
camera_posizione += speed * elapsedSec * camLeft;
if (keyState.IsKeyDown(Keys.D))
camera_posizione -= speed * elapsedSec * camLeft;
if (keyState.IsKeyDown(Keys.W))
camera_posizione += speed * elapsedSec * camLook;
if (keyState.IsKeyDown(Keys.S))
camera_posizione -= speed * elapsedSec * camLook;

//questo per aggiornare la visuale in base alle rotazioni del mouse
Mie_variabili.View = Matrix.CreateLookAt(camera_posizione, camera_posizione + camLook, camUp);

Vi prego, ditemi perchè usiamo le righe di "rot" per aggiornare la visuale. Non ha senso!!!
Vi scongiuro, rispondetemi!

[aguayo]

Vector3.Transform (Vector3, Matrix) Transforms a 3D vector by the given matrix.
by MSDN microsoft

[Toty_]

Vector3.Transform (Vector3, Matrix) Transforms a 3D vector by the given matrix.
by MSDN microsoft

Cherno mi ha detto che Vector3.Transform moltiplica un Vector3 per una matrice e ha ragione.

Il problema adesso è un altro: nel codice precedentemente postato, non capisco perchè bisogna estrapolare le righe della matrice di rotazione e non le colonne (per creare i tre vettori da usare per la rotazione della visuale). Mi sembra più un problema di trigonometria o di logica, non so.

Sapete dare una risposta?

[Toty_]

XNA si basa su Directx o su OpenGL ?

Mi serve per capire come sono disposte le matrici (con le Directx i punti sono 1x4 mentre con OpenGL sono 4x1, poi cambierebbero anche le matrici di rotazione e di traslazione).

[wedra]

L' ho già detto in Talent Zone.

Non puoi (cioè, si puoi, lo stai facendo ) iniziare un qualsivoglia progetto senza documentarti prima.

E questa tua ultima domanda non fa che confermare quanto detto sopra: XNA è "basato" su DirectX, e non sapere questo già è un punto a sfavore

Per il discorso righe e matrici: come già evidenziato, su MSDN trovi tutto ciò che ti serve, ed anche nella guida di XNA... ho appena controllato

Le matrici possono essere lette sia in orizzontale che in verticale... riporto paro paro dalla guida

Matrices use a row vector layout in the XNA Framework. Matrices can be either row vector or column vector. Row vector matrices view vectors as a row from left to right, while column vector matrices view vectors as a column from top to bottom. For example, the x, y, and z of a matrix's translation vector in the XNA Framework would correspond to the fields M41, M42, M43.

Il che significa che in una matrice di traslazione le coordinate sono rappresentate dai campi 1,2, e 3 della 4 riga.

Ah, nella guida c'è anche scritto come creare una telecamera, a mò di guida: più risposte di così, cosa vuoi di più dalla vita?

[Toty_]

L' ho già detto in Talent Zone.

Non puoi (cioè, si puoi, lo stai facendo ) iniziare un qualsivoglia progetto senza documentarti prima.

E questa tua ultima domanda non fa che confermare quanto detto sopra: XNA è "basato" su DirectX, e non sapere questo già è un punto a sfavore

Per il discorso righe e matrici: come già evidenziato, su MSDN trovi tutto ciò che ti serve, ed anche nella guida di XNA... ho appena controllato

Le matrici possono essere lette sia in orizzontale che in verticale... riporto paro paro dalla guida


Il che significa che in una matrice di traslazione le coordinate sono rappresentate dai campi 1,2, e 3 della 4 riga.

Ah, nella guida c'è anche scritto come creare una telecamera, a mò di guida: più risposte di così, cosa vuoi di più dalla vita?

Ok, scusa era solo un dubbio. Questo non significa che io non sappia cosa sono (e come si usano) le matrici. Solo che, cerca di capire, non solo concetti facili.

Prima di tutto, ho guardato su msdn ma non ci capisco molto. E poi quale sarebbe la guida di xna?

Forse non hai letto con attenzione tutta la discussione perchè, a parte questo dubbio su directx o opengl, io sto cercando di capire perchè per ruotare una visuale serve creare tre vettori che rappresentano le righe della matrice di rotazione (e comunque adesso so bene come si dispongono gli elementi all'interno di una matrice per traslare o ruotare).

Comunque sono informato (pensa che ho studiato per dei mesi il c# e ora le matrici di trasformazione), non sono uno stupido che vuole farvi perdere tempo.
Se vuoi, ti posto (per l'ennesima volta) il codice che mi sta creando problemi:

// Crea una matrice di rotazione secondo i vari angoli di rotazione
Matrix rot = Matrix.CreateFromYawPitchRoll(camera_rotazione, camera_beccheggio, camera_rollio);
// Calcola i vettori per la matrice di rotazione corrente.

Vector3 camUp = newVector3(rot.M21,rot.M22,rot.M23); //seconda riga di rot
Vector3 camLook = newVector3(rot.M31,rot.M32,rot.M33); //terza riga di rot
Vector3 camLeft = newVector3(rot.M11,rot.M12,rot.M13); //prima riga di rot
//...
if (keyState.IsKeyDown(Keys.A))
camera_posizione += speed * elapsedSec * camLeft;
if (keyState.IsKeyDown(Keys.D))
camera_posizione -= speed * elapsedSec * camLeft;
if (keyState.IsKeyDown(Keys.W))
camera_posizione += speed * elapsedSec * camLook;
if (keyState.IsKeyDown(Keys.S))
camera_posizione -= speed * elapsedSec * camLook;
//...
Mie_variabili.View = Matrix.CreateLookAt(camera_posizione, camera_posizione + camLook, camUp);

Non ho ancora capito il senso delle parti che ho segnato in grassetto nel codice.

Qualcuno può dirmi il significato di questi tre vettori?

[Toty_]

ehi anch'io sto cercando di studiare xna...anche se da poco
cameraDirection = Vector3.Transform(cameraDirection,Matrix.CreateFro mAxisAngle(cameraUp, (-MathHelper.PiOver4 / 180) * (Mouse.GetState().X - prevMouseState.X)));

quando sposto il mouse sull'asse x cambia direzione in cui guarda la telecamera in proporzione allo spostamento del mouse...da dove studi?cioè usi qualche libro?

Ho prima studiato il c# per 7-8 mesi sui vari siti.
Ora sto cercando di studiare XNA da una guida: ti basterà andare su google e scrivere "wilez". Purtroppo, il caro wilez non si sofferma molto (a dire il vero, per niente) sull'uso delle matrici e della trigonometria.