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

Aktuelle Zeit: Fr Jul 18, 2025 16:34

Foren-Übersicht » Programmierung » OpenGL 		Unbeantwortete Themen | Aktive Themen


Ein neues Thema erstellen Auf das Thema antworten  Seite 1 von 1
  [ 6 Beiträge ] 
  Vorheriges Thema | Nächstes Thema 
Autor Nachricht
Flash
BeitragVerfasst: Mi Feb 15, 2006 22:50 
Offline
Guitar Hero
Benutzeravatar

Registriert: Do Sep 25, 2003 15:56
Beiträge: 7810
Wohnort: Sachsen - ERZ / C
Programmiersprache: Java (, Pascal)
Ich muss für ein CG-Projekt in der Uni die Normalen per hand berechnen. Dazu muss ich bekanntlich die transponierte Inverse der Modelviewmatrix berechnen.
Da das invertieren (dank glScale) nicht ganz so einfach ist, suche ich fertigen Code der mir die arbeit abnimmt.

Wer also was hat, bitte posten. ;)

_________________
Blog: kevin-fleischer.de und fbaingermany.com
Nach oben
 Profil  
Mit Zitat antworten  
Lyr
 Betreff des Beitrags:
BeitragVerfasst: Mi Feb 15, 2006 23:18 
Offline
DGL Member

Registriert: So Sep 26, 2004 05:57
Beiträge: 190
Wohnort: Linz
Also wenns nur um das invertieren geht ... ist C++ und noch dazu etwas Klassen und "normale" Funktionen gemischt, aber ich denk er sollte dennoch halbwegs verständlich sein:

Code:
  1. inline FLP32 Determinante2x2( FLP32 a1, FLP32 a2, FLP32 b1, FLP32 b2 )
  2. {
  3.     return a1 * b2 - b1 * a2;
  4. }
  5.  
  6. inline FLP32 Determinante3x3( FLP32 a1, FLP32 a2, FLP32 a3,
  7.                              FLP32 b1, FLP32 b2, FLP32 b3,
  8.                              FLP32 c1, FLP32 c2, FLP32 c3 )
  9. {
  10.     return a1 * Determinante2x2( b2, b3, c2, c3 ) - b1 * Determinante2x2( a2, a3, c2, c3 ) + c1 * Determinante2x2( a2, a3, b2, b3 );
  11. }
  12.  
  13. void Matrix4::Inverse()
  14. {
  15.  
  16.     Matrix4  L_Result;
  17.     FLP32       L_Det;
  18.  
  19.     L_Result.xx =  Determinante3x3( yy, zy, wy, yz, zz, wz, yw, zw, ww );
  20.     L_Result.yx = -Determinante3x3( yx, zx, wx, yz, zz, wz, yw, zw, ww );
  21.     L_Result.zx =  Determinante3x3( yx, zx, wx, yy, zy, wy, yw, zw, ww );
  22.     L_Result.wx = -Determinante3x3( yx, zx, wx, yy, zy, wy, yz, zz, wz );
  23.  
  24.     L_Result.xy = -Determinante3x3( xy, zy, wy, xz, zz, wz, xw, zw, ww );
  25.     L_Result.yy =  Determinante3x3( xx, zx, wx, xz, zz, wz, xw, zw, ww );
  26.     L_Result.zy = -Determinante3x3( xx, zx, wx, xy, zy, wy, xw, zw, ww );
  27.     L_Result.wy =  Determinante3x3( xx, zx, wx, xy, zy, wy, xz, zz, wz );
  28.  
  29.     L_Result.xz =  Determinante3x3( xy, yy, wy, xz, yz, wz, xw, yw, ww );
  30.     L_Result.yz = -Determinante3x3( xx, yx, wx, xz, yz, wz, xw, yw, ww );
  31.     L_Result.zz =  Determinante3x3( xx, yx, wx, xy, yy, wy, xw, yw, ww );
  32.     L_Result.wz = -Determinante3x3( xx, yx, wx, xy, yy, wy, xz, yz, wz );
  33.  
  34.     L_Result.xw = -Determinante3x3( xy, yy, zy, xz, yz, zz, xw, yw, zw );
  35.     L_Result.yw =  Determinante3x3( xx, yx, zx, xz, yz, zz, xw, yw, zw );
  36.     L_Result.zw = -Determinante3x3( xx, yx, zx, xy, yy, zy, xw, yw, zw );
  37.     L_Result.ww =  Determinante3x3( xx, yx, zx, xy, yy, zy, xz, yz, zz );
  38.  
  39.     L_Det = ( xx * L_Result.xx ) + ( xy * L_Result.yx ) + (xz * L_Result.zx ) + ( xw * L_Result.wx );
  40.  
  41.     // Hier evntl. L_Det auf 0 prüfen, in diesem Fall ist die Matrix singular und kann nicht invertiert werden.
  42.     L_Det = 1.0f / L_Det;
  43.  
  44.     *this   = L_Result;
  45.  
  46.     xx *= L_Det;
  47.     yx *= L_Det;
  48.     zx *= L_Det;
  49.     wx *= L_Det;
  50.  
  51.     xy *= L_Det;
  52.     yy *= L_Det;
  53.     zy *= L_Det;
  54.     wy *= L_Det;
  55.  
  56.     xz *= L_Det;
  57.     yz *= L_Det;
  58.     zz *= L_Det;
  59.     wz *= L_Det;
  60.  
  61.     xw *= L_Det;
  62.     yw *= L_Det;
  63.     zw *= L_Det;
  64.     ww *= L_Det;
  65. }
  66.  


FLP32 ist hier als float definiert, kannst natürlich auch doublen.
Nach oben
 Profil  
Mit Zitat antworten  
Flash
 Betreff des Beitrags:
BeitragVerfasst: Mi Feb 15, 2006 23:47 
Offline
Guitar Hero
Benutzeravatar

Registriert: Do Sep 25, 2003 15:56
Beiträge: 7810
Wohnort: Sachsen - ERZ / C
Programmiersprache: Java (, Pascal)
Hmm...gut...zumindest eine Vorlage hab ich damit. Eine Hardcore "C" lösung hat wohl keiner? Also irgendwas wo nur auf nem Feld rumgerödelt wird... (klingt wie Bundeswehr ;))

_________________
Blog: kevin-fleischer.de und fbaingermany.com
Nach oben
 Profil  
Mit Zitat antworten  
Delphic
 Betreff des Beitrags:
BeitragVerfasst: Do Feb 16, 2006 05:48 
Offline
DGL Member

Registriert: Do Mai 30, 2002 18:48
Beiträge: 1617
also was du als da auf nur einem feld herumrödeln verstehst... ja das geht, ich hab aber zweifel, daß das besonders schnell geht - könntest hierzu im grunde den agsuss algorithmus gebrauchen. hier also die handmethode, um matrizen zu invertieren; Man schreibt die matrix und die Einheitsmatrix nebeneinander, z.B.:
Code:
  1.  
  2. 1 0 | 7 4
  3. 0 1 | 1 0
  4.  

dann rödelt man mit zeilenumformungen herum, bis man auf der rechten seite die einheitsmatrix stehen hat:
Erstmal die Gauss Schritte:
Code:
  1.  
  2. 1/7 0 | 1 4/7
  3. 0   1 | 1 0
  4.  

Code:
  1.  
  2. 1/7 0    | 1 4/7
  3. -1/7   1 | 0 -4/7
  4.  

Code:
  1.  
  2. 1/7 0  | 1 4/7
  3. -1/7 1 | 0 -4/7
  4.  

Code:
  1.  
  2. 1/7 0    | 1 4/7
  3. 1/4 -7/4 | 0 1
  4.  

Und Rücksubstitution
Code:
  1.  
  2. 0   1    | 1 0
  3. 1/4 -7/4 | 0 1
  4.  

. Dann steht links das, was man haben will. Test... ja stimmt. Aber ob das viel besser ist, als die Determinantenvariante... Da spart man sich immerhin einige male dividieren. Und was spricht denn gegen die Sache mit der Determinante?
Nach oben
 Profil  
Mit Zitat antworten  
Pellaeon
 Betreff des Beitrags:
BeitragVerfasst: Do Feb 16, 2006 10:53 
Offline
DGL Member
Benutzeravatar

Registriert: Mo Apr 25, 2005 17:51
Beiträge: 464
Von was genau brauchst du denn die Normalen?

_________________
__________
"C++ is the best language for garbage collection principally because it creates less garbage." Bjarne Stroustrup
Nach oben
 Profil  
Mit Zitat antworten  
Flash
 Betreff des Beitrags:
BeitragVerfasst: Do Feb 16, 2006 13:08 
Offline
Guitar Hero
Benutzeravatar

Registriert: Do Sep 25, 2003 15:56
Beiträge: 7810
Wohnort: Sachsen - ERZ / C
Programmiersprache: Java (, Pascal)
Nö..ich wollte net das Gaus Jordan Verfahren sondern eine C-Implementation, ohne Klassen die nur mit einem Feld arbeitet ;)

Wir sollen die Normalen für einen beliebigen Körper in der Szene per Hand transformieren. Ich hab nen Würfel, der ständig verwendet wird. Für den will ich die Normalen entsprechend setzen.

_________________
Blog: kevin-fleischer.de und fbaingermany.com
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
  [ 6 Beiträge ] 
Foren-Übersicht » Programmierung » OpenGL


Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder und 7 Gäste

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 | 16 Queries | GZIP : On ]