Files |  Tutorials |  Articles |  Links |  Home |  Team |  Forum |  Wiki |  Impressum

Aktuelle Zeit: Fr Jul 18, 2025 15:14

Foren-Übersicht » Programmierung » Mathematik-Forum 		Unbeantwortete Themen | Aktive Themen


Ein neues Thema erstellen Auf das Thema antworten  Seite 1 von 1
  [ 5 Beiträge ] 
  Vorheriges Thema | Nächstes Thema 
Autor Nachricht
michael2
BeitragVerfasst: Mo Jul 06, 2009 21:45 
Offline
DGL Member

Registriert: Mo Jul 06, 2009 13:26
Beiträge: 3
hallo ihr,

bin neu hier. programmiere zwar mit c++, aber das wiki hat mir schon oft geholfen :)

also ich hätte da ein problem: ich mache ein kleines weltraumspiel. man kann rumfliegen, sprich: sich vorwärtsbewegen und die richtung ändern. das heißt ich rufe immer wieder mal glRotate und glTranslate auf, sodass ich die matrix habe, die ich brauche um die objekte im raum richtig positioniert zu haben. nun will ich aber die position des betrachters wissen, also die koordinaten des ursprungs im bezug auf das weltkoordinatensystem(identity-matrix). wie kann ich das aus der modelview-matrix herausrechnen? zu erst dachte ich, ich nehm einfach den translationsteil, aber das war falsch, weil da die rotation schon reingerechnet ist.

hoffe ich konnte das jetzt halbwegs verständlich machen :) danke schonmal im voraus

grüße
michael
Nach oben
 Profil  
Mit Zitat antworten  
Coolcat
 Betreff des Beitrags:
BeitragVerfasst: Mo Jul 06, 2009 21:54 
Offline
DGL Member
Benutzeravatar

Registriert: Do Dez 29, 2005 12:28
Beiträge: 2249
Wohnort: Düsseldorf
Programmiersprache: C++, C#, Java
Nun der einfachste und sinnvollste Weg ist die Position der Kamera beim setzen der Kamera einfach irgendwo zu speichern. Idealerweise hat man ja sowieso irgendeine Form von Kamera-Klasse die das wunderbar erledigen kann.

Wenn du das wirklich aus der ModelViewMatrix holen willst:
Sofern deine ModelViewMatrix von Weltkoordinaten in Kamerakoordinaten rechnet, musst du eigentlich nur die Matrix invertieren und dann damit die Position der Kamera in Kamerakoordinaten (der Punkt (0,0,0,1)) transformieren. Letztlich nimmst du also die Translation der invertierten Matrix.

P.S. Willkommen im Forum :)

_________________
Yeah! :mrgreen:
Nach oben
 Profil  
Mit Zitat antworten  
michael2
 Betreff des Beitrags:
BeitragVerfasst: Di Jul 07, 2009 17:21 
Offline
DGL Member

Registriert: Mo Jul 06, 2009 13:26
Beiträge: 3
danke! :)
an irgendwas mit invertieren dachte ich auch schon :D

ok, zum invertieren hab ich das da gefunden: http://wiki.delphigl.com/index.php/Techniken_zur_Matrixinversion

aber irgendwie tut das immer noch nicht so ganz...

das folgende sollte die berechnung von dem v aus dem wiki machen:
Code:
  1.  
  2. glGetDoublev(GL_MODELVIEW_MATRIX, matrix);
  3. pos[0]=-matrix[12]*matrix[0]-matrix[13]*matrix[4]-matrix[14]*matrix[8];
  4. pos[1]=-matrix[12]*matrix[1]-matrix[13]*matrix[5]-matrix[14]*matrix[9];
  5. pos[2]=-matrix[12]*matrix[2]-matrix[13]*matrix[6]-matrix[14]*matrix[10];
  6.  


ist da ein fehler erkennbar?
Nach oben
 Profil  
Mit Zitat antworten  
Coolcat
 Betreff des Beitrags:
BeitragVerfasst: Di Jul 07, 2009 17:59 
Offline
DGL Member
Benutzeravatar

Registriert: Do Dez 29, 2005 12:28
Beiträge: 2249
Wohnort: Düsseldorf
Programmiersprache: C++, C#, Java
Ich empfehle dir immer noch den Weg über die Kamera-Klasse! Ist viel einfacher und funktioniert auch in Fällen wo du z.B. bereits eine Lokale-Objekt-Matrix in der ModelViewMatrix mit drin hast.

Zitat:
ist da ein fehler erkennbar?

Auf den ersten Blick würde ich sagen das du da nicht wirklich die Inverse berechnest. Ich habe mir das jetzt aber nicht genauer angeschaut.
Aber das was du dort machst nutzt vermutlich einen Spezialfall aus und funktioniert nur dann, wenn du ausschließlich Rotationen und Translationen verwendet hast. Sobald du auch nur eine Skalierung oder Scherung einbaust klappt das nicht mehr. Vermutlich liegt es daran.

Ich geb dir einfach mal diesen Code aus meiner Mathelib, ist zwar C++, aber da du das ja selbst benutzt.... ;)
Code:
  1. template<class T> inline CMatrix44<T> CMatrix44<T>::getInverse() const
  2. {
  3.     CMatrix44<T> matResult;
  4.     const T* mat = &_11;
  5.     T* dst = &matResult._11;
  6.  
  7.     /* Code taken from Article
  8.      * "AP-928 Streaming SIMD Extensions -Inverse of 4x4 Matrix"
  9.      * code performs 4x4-matrix inversion with Cramer's Rule
  10.      *
  11.      * File: 24504301.pdf
  12.      * Download: http://www.intel.com/design/pentiumiii/sml/245043.htm */
  13.  
  14.     T tmp[12]; /* temp array for pairs             */
  15.     T src[16]; /* array of transpose source matrix */
  16.     T det;     /* determinant                      */
  17.  
  18.     /* transpose matrix */
  19.     for (int i = 0; i < 4; i++) {
  20.         src[i]      = mat[i*4];
  21.         src[i + 4]  = mat[i*4 + 1];
  22.         src[i + 8]  = mat[i*4 + 2];
  23.         src[i + 12] = mat[i*4 + 3];
  24.     }
  25.  
  26.     /* calculate pairs for first 8 elements (cofactors) */
  27.     tmp[0]  = src[10] * src[15];
  28.     tmp[1]  = src[11] * src[14];
  29.     tmp[2]  = src[9]  * src[15];
  30.     tmp[3]  = src[11] * src[13];
  31.     tmp[4]  = src[9]  * src[14];
  32.     tmp[5]  = src[10] * src[13];
  33.     tmp[6]  = src[8]  * src[15];
  34.     tmp[7]  = src[11] * src[12];
  35.     tmp[8]  = src[8]  * src[14];
  36.     tmp[9]  = src[10] * src[12];
  37.     tmp[10] = src[8]  * src[13];
  38.     tmp[11] = src[9]  * src[12];
  39.  
  40.     /* calculate first 8 elements (cofactors) */
  41.     dst[0]  = tmp[0]*src[5] + tmp[3]*src[6] + tmp[4]*src[7];
  42.     dst[0] -= tmp[1]*src[5] + tmp[2]*src[6] + tmp[5]*src[7];
  43.     dst[1]  = tmp[1]*src[4] + tmp[6]*src[6] + tmp[9]*src[7];
  44.     dst[1] -= tmp[0]*src[4] + tmp[7]*src[6] + tmp[8]*src[7];
  45.     dst[2]  = tmp[2]*src[4] + tmp[7]*src[5] + tmp[10]*src[7];
  46.     dst[2] -= tmp[3]*src[4] + tmp[6]*src[5] + tmp[11]*src[7];
  47.     dst[3]  = tmp[5]*src[4] + tmp[8]*src[5] + tmp[11]*src[6];
  48.     dst[3] -= tmp[4]*src[4] + tmp[9]*src[5] + tmp[10]*src[6];
  49.     dst[4]  = tmp[1]*src[1] + tmp[2]*src[2] + tmp[5]*src[3];
  50.     dst[4] -= tmp[0]*src[1] + tmp[3]*src[2] + tmp[4]*src[3];
  51.     dst[5]  = tmp[0]*src[0] + tmp[7]*src[2] + tmp[8]*src[3];
  52.     dst[5] -= tmp[1]*src[0] + tmp[6]*src[2] + tmp[9]*src[3];
  53.     dst[6]  = tmp[3]*src[0] + tmp[6]*src[1] + tmp[11]*src[3];
  54.     dst[6] -= tmp[2]*src[0] + tmp[7]*src[1] + tmp[10]*src[3];
  55.     dst[7]  = tmp[4]*src[0] + tmp[9]*src[1] + tmp[10]*src[2];
  56.     dst[7] -= tmp[5]*src[0] + tmp[8]*src[1] + tmp[11]*src[2];
  57.  
  58.     /* calculate pairs for second 8 elements (cofactors) */
  59.     tmp[0]  = src[2]*src[7];
  60.     tmp[1]  = src[3]*src[6];
  61.     tmp[2]  = src[1]*src[7];
  62.     tmp[3]  = src[3]*src[5];
  63.     tmp[4]  = src[1]*src[6];
  64.     tmp[5]  = src[2]*src[5];
  65.     tmp[6]  = src[0]*src[7];
  66.     tmp[7]  = src[3]*src[4];
  67.     tmp[8]  = src[0]*src[6];
  68.     tmp[9]  = src[2]*src[4];
  69.     tmp[10] = src[0]*src[5];
  70.     tmp[11] = src[1]*src[4];
  71.  
  72.     /* calculate second 8 elements (cofactors) */
  73.     dst[8]   = tmp[0]*src[13]  + tmp[3]*src[14]  + tmp[4]*src[15];
  74.     dst[8]  -= tmp[1]*src[13]  + tmp[2]*src[14]  + tmp[5]*src[15];
  75.     dst[9]   = tmp[1]*src[12]  + tmp[6]*src[14]  + tmp[9]*src[15];
  76.     dst[9]  -= tmp[0]*src[12]  + tmp[7]*src[14]  + tmp[8]*src[15];
  77.     dst[10]  = tmp[2]*src[12]  + tmp[7]*src[13]  + tmp[10]*src[15];
  78.     dst[10] -= tmp[3]*src[12]  + tmp[6]*src[13]  + tmp[11]*src[15];
  79.     dst[11]  = tmp[5]*src[12]  + tmp[8]*src[13]  + tmp[11]*src[14];
  80.     dst[11] -= tmp[4]*src[12]  + tmp[9]*src[13]  + tmp[10]*src[14];
  81.     dst[12]  = tmp[2]*src[10]  + tmp[5]*src[11]  + tmp[1]*src[9];
  82.     dst[12] -= tmp[4]*src[11]  + tmp[0]*src[9]   + tmp[3]*src[10];
  83.     dst[13]  = tmp[8]*src[11]  + tmp[0]*src[8]   + tmp[7]*src[10];
  84.     dst[13] -= tmp[6]*src[10]  + tmp[9]*src[11]  + tmp[1]*src[8];
  85.     dst[14]  = tmp[6]*src[9]   + tmp[11]*src[11] + tmp[3]*src[8];
  86.     dst[14] -= tmp[10]*src[11] + tmp[2]*src[8]   + tmp[7]*src[9];
  87.     dst[15]  = tmp[10]*src[10] + tmp[4]*src[8]   + tmp[9]*src[9];
  88.     dst[15] -= tmp[8]*src[9]   + tmp[11]*src[10] + tmp[5]*src[8];
  89.  
  90.     /* calculate determinant */
  91.     det=src[0]*dst[0]+src[1]*dst[1]+src[2]*dst[2]+src[3]*dst[3];
  92.  
  93.     /* calculate matrix inverse */
  94.     det = 1/det;
  95.     for (int j = 0; j < 16; ++j) {
  96.         dst[j] *= det;
  97.     }
  98.  
  99.     return matResult;
  100. }

_________________
Yeah! :mrgreen:
Nach oben
 Profil  
Mit Zitat antworten  
michael2
 Betreff des Beitrags:
BeitragVerfasst: Di Jul 07, 2009 18:26 
Offline
DGL Member

Registriert: Mo Jul 06, 2009 13:26
Beiträge: 3
ja, das nutzt aus, dass nur rotationen und translationen vorkommen. skalierungen und scherungen mach ich nicht. was ich geschrieben hab sollte einfach den translationsteil der inversen ausrechnen, was ja genau das ist was ich suche. laut wiki muss man dazu nur den 3x3 rotationsteil nehmen, negieren und transponieren und das dann mal dem translationsteil machen; das sollte dann den translationsteil der inversen geben.

also ich probier noch ein wenig rum und wenn alles nichts hilft pronbier ich mal dein codestück aus :)
Nach oben
 Profil  
Mit Zitat antworten  
Beiträge der letzten Zeit anzeigen:  Sortiere nach  
Ein neues Thema erstellen Auf das Thema antworten  Seite 1 von 1
  [ 5 Beiträge ] 
Foren-Übersicht » Programmierung » Mathematik-Forum


Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder und 1 Gast

Du darfst keine neuen Themen in diesem Forum erstellen.
Du darfst keine Antworten zu Themen in diesem Forum erstellen.
Du darfst deine Beiträge in diesem Forum nicht ändern.
Du darfst deine Beiträge in diesem Forum nicht löschen.
Du darfst keine Dateianhänge in diesem Forum erstellen.

Suche nach:
Gehe zu:  
  Powered by phpBB® Forum Software © phpBB Group
Deutsche Übersetzung durch phpBB.de
[ Time : 0.008s | 14 Queries | GZIP : On ]