DGL • Thema anzeigen - Informationen aus aktueller Matrix extrahieren???

Informationen aus aktueller Matrix extrahieren???

Moderator: DGL-Team

Seite 1 von 1

[ 13 Beiträge ]

Vorheriges Thema | Nächstes Thema

Autor

Nachricht

Andyh

Betreff des Beitrags: Informationen aus aktueller Matrix extrahieren???

Verfasst: Mo Okt 10, 2005 07:26

DGL Member

Registriert: Do Jun 09, 2005 13:48
Beiträge: 117
Wohnort: Sankt Augustin

Hallo,

ich möchte die Position, die Blickrichtung und den Upvector aus der aktuellen Matrix errechnen.
Soweit ich weiß ist die Position in den ersten drei Elementen der vierten Matrixspalte enthalten.
Wie komme ich aber jetzt an die Blickrichtung un den Upvector?

Danke!

Nach oben

Flo

Betreff des Beitrags:

Verfasst: Mo Okt 10, 2005 09:08

DGL Member

Registriert: Do Jun 19, 2003 10:44
Beiträge: 991
Wohnort: Karlsfeld (nahe München)

http://wiki.delphigl.com/index.php/Matrix

Erste Spalte(bzw. die ersten 3 Elemente davon): X- Achse
Zweite Spalte: Y-Achse
dritte Spalte: Z-Achse
vierte wie du schon richtig gesagt hattest die Position.

MfG
Flo

_________________
Danke an alle, die mir (und anderen) geholfen haben.
So weit... ...so gut

Nach oben

Andyh

Betreff des Beitrags: erst mal danke, aber...

Verfasst: Mo Okt 10, 2005 09:43

DGL Member

Registriert: Do Jun 09, 2005 13:48
Beiträge: 117
Wohnort: Sankt Augustin

so weit, so gut...

mein Verständnis der Sache ist die, dass die einzelnen Spalten Vektoren darstellen. Mit einem
Vektor wird aber ein Punkt im Koordinatensystem beschrieben. Wie bekomme ich also aus einem
Punkt eine Drehung errechnet??? Und wie einen Upvector???

Nach oben

Flo

Betreff des Beitrags:

Verfasst: Mo Okt 10, 2005 15:09

DGL Member

Registriert: Do Jun 19, 2003 10:44
Beiträge: 991
Wohnort: Karlsfeld (nahe München)

Sag mir erstmal wofür du das brauchst und was du unter einen UpVektor verstehst.

MfG
Flo

_________________
Danke an alle, die mir (und anderen) geholfen haben.
So weit... ...so gut

Nach oben

Flash

Betreff des Beitrags:

Verfasst: Mo Okt 10, 2005 15:19

Guitar Hero

Registriert: Do Sep 25, 2003 15:56
Beiträge: 7810
Wohnort: Sachsen - ERZ / C
Programmiersprache: Java (, Pascal)

@Flo: Na der Up Vector gibt an wo oben ist. Den brauch man um eine Ansicht in 3D zu spezifizieren. Guck mal bei gluLookAt.

_________________
Blog: kevin-fleischer.de und fbaingermany.com

Nach oben

Flo

Betreff des Beitrags:

Verfasst: Mo Okt 10, 2005 15:56

DGL Member

Registriert: Do Jun 19, 2003 10:44
Beiträge: 991
Wohnort: Karlsfeld (nahe München)

Also wenn ich den WIki Artikel richtig verschaden habe dann ist dies der Vektor (0,1,0) wenn die Projektions und Modelview matrix Identitätsmatrizen sind.

Die Frage nach dem Up-Vektor lautet also etwas anders formuliert, wie kann ich das einwirken der Modelview und Projektionsmatrix rückgängig machen. Du brauchst also eigentlich nur gluUnProject mit den richtigen Parametern aufrufen und du hast deinen Upvektor. Also die ersten 3 Parameter sind die Komponenten von (0,1,0), modelview, projection, viewport dürfte klar sein und das Ergebnis ist der gesuchte Upvektor für die übergebene Model und Projektionsmatrix.

Eventuel kürtzt sich durch die Nullen noch viel raus wenn du die Rechung per Hand und nicht per gluUnProject machst.

MfG
Flo

_________________
Danke an alle, die mir (und anderen) geholfen haben.
So weit... ...so gut

Nach oben

LarsMiddendorf

Betreff des Beitrags:

Verfasst: Mo Okt 10, 2005 16:04

DGL Member

Registriert: Sa Dez 28, 2002 11:13
Beiträge: 2244

Zitat:

Also wenn ich den WIki Artikel richtig verschaden habe dann ist dies der Vektor (0,1,0) wenn die Projektions und Modelview matrix Identitätsmatrizen sind.

Der Up Vektor müßte dann in der zweiten Spalte der Matrix stehen. Schließlich sind die Spaltenvektoren die Einheitsvektoren im neuen Koordinantensystem.

Zuletzt geändert von LarsMiddendorf am Mo Okt 10, 2005 16:20, insgesamt 1-mal geändert.

Nach oben

Flo

Betreff des Beitrags:

Verfasst: Mo Okt 10, 2005 16:14

DGL Member

Registriert: Do Jun 19, 2003 10:44
Beiträge: 991
Wohnort: Karlsfeld (nahe München)

Hatte ich zuerst auch gedacht das er das will, aber was will er mit so einen transformierten UpVektor der keiner mehr ist ?

_________________
Danke an alle, die mir (und anderen) geholfen haben.
So weit... ...so gut

Nach oben

Andyh

Betreff des Beitrags: danke, danke, danke...

Verfasst: Di Okt 11, 2005 16:25

DGL Member

Registriert: Do Jun 09, 2005 13:48
Beiträge: 117
Wohnort: Sankt Augustin

zuerst einmal Dank an alle die versucht haben die Dunkelheit in meinem Programmiererhirn mit etwas Erleuchtung zu vertreiben!

Ich hatte irgendwie Tomaten auf den Augen. Es ist mir jetzt klar, dass die ersten drei Spaltzen die Ausrichtung der Ebenen (X/Y/Z) angeben. Ich brauche also immer nur zwei Informationen um die Ausrichtung meines aktuellen Koordinatensytems zu erhalten. Ist die Matrix

1,0,0,0
0,1,0,0
0,0,1,0
0,0,0,1

stimmt sie mit dem Basiskoordinatensystem überein. Ist sie

1,1,0,0
0,1,0,0
0,0,1,0
0,0,0,1

ist mein Koordinatensystem um 45° gedreht. In der Matrix stehen übrigens nicht die Einheitsvektoren sondern die "ungekürzten" Vektoren.

Das Problem was ich hatte war folgendes: Ich habe eine Kamera und kann auch schön um alle drei Achsen drehen und die kamera in jede beliebige Richtung verschieben. Auch die Blickrichtung kann ich beliebig verändern. mein Problem war, dass ich den drehpunkt nicht ändern kann. der liegt immer im 0-Punkt des Basis Koordinatensystems. Ich sitze jetzt schon bald zwei Monate an diesem Problem und werde bald verrückt.

Den UpVector brauchte ich um bei einer Positionsänderung die Lage nicht ändern zu müssen.

Ich habe mal ein paar Kameramodule angefügt. Benötigte Definitionen findet man im ersten Modul als Kommentar.

Kamera basierend auf Matrix Operationen:

Code:

 
unit Camera;
 
interface
 
  Uses DglOpenGL, OpenGLUtil, Windows, Classes;
 
  //type
  //TArrMatrix = array [0..15] of TGLFloat;
  //TGLVector = packed record
  //  X,Y,Z: GLfloat;
  //end;
 
  type TCameraMatrix=Class
    Matrix: TArrMatrix;
    InverseMatrix: TArrMatrix;
    procedure Identity;
    procedure Load(M: TArrMatrix);
    constructor Create;
  end;
 
  TCamera=Class
    CameraMatrix: TCameraMatrix;
    Enabled  : boolean;
    Initiated: boolean;
    constructor Create;
    destructor Destroy;
    function Position: TGLvector;
    function UpVector: TGLvector;
    function ViewDirection: TGLvector;
    procedure RestorePosition(pos: integer);
    procedure SavePosition(pos: integer);
    procedure RotateCamera(ix, iy, iz: TGLdouble);
    procedure TranslateCamera(ix, iy, iz: TGLdouble);
    procedure CameraHome;
    procedure PositionCamera(PositionVec: TGLvector;
                                   ViewVec: TGLvector;
                                   upVec: TGLvector);
    procedure Apply;
  private
    HomeMatrix: TCameraMatrix;
    PosArray: array [0..9] of TCameraMatrix;
    FCameraDistance: TGLvector;
    FPointOfRotation: TGLvector;
    procedure LogMatrix(Header: string; M: TArrMatrix);
    procedure Identity;
    procedure RotateMatrix(ix, iy, iz: TGLdouble);
    procedure Offset(x, y, z: TGLfloat);
    procedure RotateRoundAxis(r: TGLfloat; axis: integer);
  published
    property CameraDistance: TGLvector read FCameraDistance;
    property PointOfRotation: TGLvector read FPointOfRotation;
  end;
  TPCamera=^TCamera;
 
const
  AXIS_X: integer = 0;
  AXIS_Y: integer = 1;
  AXIS_Z: integer = 2;
 
var
  LogFile: TextFile;
 
implementation
 
(*
function GetArrIdentity:TArrMatrix;
begin
  result[0]:=1.0;result[1]:=0.0;result[2]:=0.0;result[3]:=0.0;
  result[4]:=0.0;result[5]:=1.0;result[6]:=0.0;result[7]:=0.0;
  result[8]:=0.0;result[9]:=0.0;result[10]:=1.0;result[11]:=0.0;
  result[12]:=0.0;result[13]:=0.0;result[14]:=0.0;result[15]:=1.0;
end;
 
function InvertMatrix (src: TArrMatrix; var inverse: TArrMatrix): boolean;
var
  t: TGLdouble;
  i, j, k, swap: integer;
  tmp: TMatrix;
begin
  result := false;
  inverse := GetArrIdentity;
 
  for i := 0 to 3 do
  begin
    for j := 0 to 3 do
    begin
      tmp[i][j] := src[i*4+j];
    end;
  end;
 
  for i := 0 to 3 do
  begin
    // look for largest element in column.
    swap := i;
    for j := i+1 to 3 do
    begin
      if abs(tmp[j][i]) > abs(tmp[i][i]) then
      begin
        swap := j;
      end;
    end;
 
    if not (swap = i) then
    begin
      // swap rows.
      for k := 0 to 3 do
      begin
        t := tmp[i][k];
        tmp[i][k] := tmp[swap][k];
        tmp[swap][k] := t;
 
        t := inverse[i*4+k];
        inverse[i*4+k] := inverse[swap*4+k];
        inverse[swap*4+k] := t;
      end;
    end;
 
    if tmp[i][i] = 0 then
    begin
    { no non-zero pivot.  the matrix is singular, which
      shouldn't happen.  This means the user gave us a bad
      matrix. }
      exit;
    end;
 
    t := tmp[i][i];
    for k := 0 to 3 do
    begin
      tmp[i][k] := tmp[i][k]/t;
      inverse[i*4+k] := inverse[i*4+k]/t;
    end;
 
    for j := 0 to 3 do
    begin
      if not (j = i) then
      begin
        t := tmp[j][i];
        for k := 0 to 3 do
        begin
          tmp[j][k] := tmp[j][k]-tmp[i][k]*t;
          inverse[j*4+k] := inverse[j*4+k]-inverse[i*4+k]*t;
        end;
      end;
    end;
  end;
  result := true;
end;
*)
constructor TCameraMatrix.Create;
begin
  Identity;
end;
 
procedure TCameraMatrix.Identity;
var
  i: integer;
begin
  Matrix := GetArrIdentity;
  InverseMatrix := GetArrIdentity;
end;
 
procedure TCameraMatrix.Load(M: TArrMatrix);
var
  i: integer;
begin
  for i:=0 to 15 do
    Matrix[i]:=M[i];
  InvertMatrix (M, InverseMatrix);
end;
 
 
procedure TCamera.RotateRoundAxis(r: TGLfloat; axis: integer);
var
  newMatrix: TArrMatrix;
begin
  glMatrixMode (GL_MODELVIEW);
 
  glPushMatrix();
 
  glLoadMatrixf(@CameraMatrix.Matrix);
 
  if(axis=AXIS_X) then
    glRotatef(r,1,0,0);
 
  if(axis=AXIS_Y) then
    glRotatef(r,0,1,0);
 
  if(axis=AXIS_Z) then
    glRotatef(r,0,0,1);
 
  glGetFloatv(GL_MODELVIEW_MATRIX, @newMatrix);
 
  CameraMatrix.Load(newMatrix);
 
  glPopMatrix();
end;
 
constructor TCamera.Create;
var
  i: integer;
begin
  AssignFile (LogFile, '.\CAMERALOG.TXT');
  Rewrite (LogFile);
 
  Initiated := false;
  CameraMatrix := TCameraMatrix.Create;
  HomeMatrix := TCameraMatrix.Create;
  for i := 0 to 9 do
    PosArray[i] := TCameraMatrix.Create;
end;
 
procedure TCamera.Identity;
begin
  CameraMatrix.Identity;
  HomeMatrix.Identity;
 
  Enabled := true;
end;
 
destructor TCamera.Destroy;
var
  i: integer;
begin
  HomeMatrix.Free;
  CameraMatrix.Free;
  for i := 0 to 9 do
    PosArray[i].Free;
end;
 
procedure TCamera.Offset(x, y, z: TGLfloat);
var
  newMatrix: TArrMatrix;
begin
  glMatrixMode (GL_MODELVIEW);
  glPushMatrix();
  glLoadIdentity();
  glTranslatef(x,y,z);
  glGetFloatv(GL_MODELVIEW_MATRIX, @newMatrix);
  LogMatrix ('Offset', newMatrix);
 
  MatrixMultiply(newMatrix,CameraMatrix.Matrix,newMatrix);
  CameraMatrix.Load(newMatrix);
  glPopMatrix();
 
  FCameraDistance.X := FCameraDistance.X + x;
  FCameraDistance.Y := FCameraDistance.Y + y;
  FCameraDistance.Z := FCameraDistance.Z + z;
  writeln (LogFile, 'Distance: ', FCameraDistance.X,
                                  FCameraDistance.Y,
                                  FCameraDistance.Z);
end;
 
 
procedure TCamera.PositionCamera(PositionVec: TGLvector;
                                       ViewVec: TGLvector;
                                       upVec: TGLvector);
var
  newMatrix: TArrMatrix;
begin
  writeln (LogFile, 'Position: ', PositionVec.X, Positionvec.Y, PositionVec.Z);
  writeln (LogFile, 'View    : ', ViewVec.X, ViewVec.Y, ViewVec.Z);
  writeln (LogFile, 'Up      : ', upVec.X, upVec.Y, upVec.Z);
 
  FPointOfRotation := ViewVec;
 
  Identity;
 
  glMatrixMode (GL_MODELVIEW);
  glPushMatrix;
  glLoadIdentity;
  gluLookAt (PositionVec.X, PositionVec.Y, PositionVec.Z,
             ViewVec.X, ViewVec.Y, ViewVec.Z,
             upVec.X, upVec.Y, upVec.Z);
  glGetFloatv(GL_MODELVIEW_MATRIX, @newMatrix);
  CameraMatrix.Load(newMatrix);
  HomeMatrix.Load(newMatrix);
  LogMatrix ('PositionCamera', newMatrix);
  if not Initiated then
  begin
    SavePosition (1);
    Initiated := true;
  end;
 
  glPopMatrix;
 
  FCameraDistance.X := PositionVec.X + ViewVec.X;
  FCameraDistance.Y := PositionVec.Y + ViewVec.Y;
  FCameraDistance.Z := PositionVec.Z + ViewVec.Z;
  writeln (LogFile, 'Distance: ', FCameraDistance.X,
                                  FCameraDistance.Y,
                                  FCameraDistance.Z);
end;
 
// Move the camera to the home position
procedure TCamera.CameraHome;
begin
  CameraMatrix.Load(HomeMatrix.Matrix);
end;
 
procedure TCamera.SavePosition (pos: integer);
var
  saveMatrix: TArrMatrix;
begin
  if (pos < 0) or (pos > 9) then
    exit;
 
  glMatrixMode (GL_MODELVIEW);
  glGetFloatv(GL_MODELVIEW_MATRIX, @saveMatrix);
  PosArray[pos].Load(saveMatrix);
end;
 
procedure TCamera.RestorePosition (pos: integer);
begin
  if (pos < 0) or (pos > 9) then
    exit;
 
  CameraMatrix.Load(PosArray[pos].Matrix);
end;
 
procedure TCamera.TranslateCamera(ix, iy, iz: TGLdouble);
begin
  Offset (ix, iy, iz);
end;
 
procedure TCamera.RotateCamera(ix, iy, iz: TGLdouble);
begin
  RotateMatrix (ix, iy, iz);
end;
 
procedure TCamera.Apply;
begin
  if not Enabled then
    exit;
 
  glMatrixMode (GL_MODELVIEW);
  //glLoadIdentity;
  //gluLookAt (CameraMatrix.Matrix[12], CameraMatrix.Matrix[13], CameraMatrix.Matrix[14],
  //           CameraMatrix.Matrix[04], CameraMatrix.Matrix[05], CameraMatrix.Matrix[06],
  //           CameraMatrix.Matrix[08], CameraMatrix.Matrix[09], CameraMatrix.Matrix[10]);
  //glTranslatef (FPointOfRotation.X,
  //              FPointOfRotation.Y,
  //              FPointOfRotation.Z);
  glLoadMatrixf(@CameraMatrix.Matrix);
end;
 
procedure TCamera.RotateMatrix (ix, iy, iz: TGLdouble);
begin
  // um den austausch von verschiedenen kameramodulen so einfach
  // wie möglich zu gestalten, wird hier ein bisschen zwischen
  // X/Y/Z hin- und hergetauscht...
  if ix <> 0.0 then
    RotateRoundAxis (-ix, AXIS_Y);
  if iy <> 0.0 then
    RotateRoundAxis (iy, AXIS_X);
  if iz <> 0.0 then
    RotateRoundAxis (iz*50, AXIS_Z);
end;
 
function TCamera.Position: TGLvector;
var
  return: TGLvector;
begin
  // position: letzte Spalte der Matrix
  InitVector (return,
              CameraMatrix.Matrix[12],
              CameraMatrix.Matrix[13],
              CameraMatrix.Matrix[14]);
  result := return;
end;
 
function TCamera.ViewDirection: TGLvector;
var
  return: TGLvector;
begin
  // view direction: dritte Spalte der Matrix (Z-Achse)
  InitVector (return,
              CameraMatrix.Matrix[08],
              CameraMatrix.Matrix[09],
              CameraMatrix.Matrix[10]);
  result := return;
end;
 
function TCamera.UpVector: TGLvector;
var
  return: TGLvector;
begin
  // view direction: zweite Spalte der Matrix (Y-Achse)
  InitVector (return,
              CameraMatrix.Matrix[04],
              CameraMatrix.Matrix[05],
              CameraMatrix.Matrix[06]);
 result := return;
end;
 
procedure TCamera.LogMatrix (Header: string; M: TArrMatrix);
begin
  writeln (LogFile, Header);
  writeln (LogFile, 'Matrix 1: ', M[00],
                                  M[01],
                                  M[02],
                                  M[03]);
  writeln (LogFile, 'Matrix 2: ', M[04],
                                  M[05],
                                  M[06],
                                  M[07]);
  writeln (LogFile, 'Matrix 3: ', M[08],
                                  M[09],
                                  M[10],
                                  M[11]);
  writeln (LogFile, 'Matrix 4: ', M[12],
                                  M[13],
                                  M[14],
                                  M[15]);
end;
 
end.
 

Kamera basierend auf GluLookAt:

Code:

 
unit Camera;
 
interface
 
  Uses DglOpenGL, OpenGLUtil, Windows, Classes;
 
  type TCameraMatrix=Class
    Matrix: TArrMatrix;
    InverseMatrix: TArrMatrix;
    procedure Identity;
    procedure Load(M: TArrMatrix);
    constructor Create;
  end;
 
  type TCamera = class
    Enabled     : boolean;
    CameraMatrix: TCameraMatrix;
    function Position: TGLvector;
    function UpVector: TGLvector;
    function ViewDirection: TGLvector;
    procedure RestorePosition(pos: integer);
    procedure SavePosition(pos: integer);
    procedure CameraHome;
    procedure RotateCamera(ix, iy, iz: TGLdouble);
    procedure TranslateCamera(ix, iy, iz: TGLdouble);
    procedure PositionCamera(PositionVec: TGLvector;
                                   ViewVec: TGLvector;
                                   upVec: TGLvector);
    procedure Apply;
    constructor Create;
    destructor Destroy;
  private
    pr       : TGLvector;        // rotation point
    vp       : TGLvector;        // Camera Position
    vu       : TGLvector;        // View Up
    vd       : TGLvector;        // View Direction
 
    vpArr    : array [0..9] of TGLvector;   // store up to 10 positions
    vdArr    : array [0..9] of TGLvector;   //            \"
    vuArr    : array [0..9] of TGLvector;   //            \"
    prArr    : array [0..9] of TGLvector;   //            \"
 
    // init werte
    vpInit, vdInit, vuInit: TGLvector;
    Initiated: boolean;
  end;
  TPCamera=^TCamera;
 
implementation
 
uses KanalUtil;
 
{ TCamera }
 
constructor TCameraMatrix.Create;
begin
  Identity;
end;
 
procedure TCameraMatrix.Identity;
var
  i: integer;
begin
  Matrix := GetArrIdentity;
  InverseMatrix := GetArrIdentity;
end;
 
procedure TCameraMatrix.Load(M: TArrMatrix);
var
  i: integer;
begin
  for i:=0 to 15 do
    Matrix[i]:=M[i];
  InvertMatrix (M, InverseMatrix);
end;
 
constructor TCamera.Create;
var
  i: integer;
begin
  Enabled := true;
  CameraMatrix := TCameraMatrix.Create;
  InitVector (vdInit, -1, -1, -1);
  InitVector (vpInit, 1, 1, 1);
  InitVector (vuInit, 0, 1, 0);
  CameraHome;
  for i := 0 to 9 do
  begin
    InitVector (vpArr[i], 0, 0, 0);
    InitVector (vdArr[i], 0, 0, 0);
    InitVector (vuArr[i], 0, 0, 0);
    InitVector (prArr[i], 0, 0, 0);
  end;
  Initiated := false;
end;
 
// Translate (pan) the camera view point
procedure TCamera.TranslateCamera(ix, iy, iz: TGLdouble);
var
  temp, right: TGLvector;
begin
  Normalize (CrossProduct(vd,vu), right);
  // distanz zum vorherigen rotationspunkt errechnen
  temp.X := ix*right.x + iy*vu.x + iz*vd.x;
  temp.Y := ix*right.y + iy*vu.y + iz*vd.y;
  temp.Z := ix*right.z + iy*vu.z + iz*vd.z;
 
  // distanz auf kamerastandort und rotationspunkt aufaddieren
  vp := AddVector (vp, temp);
  pr := AddVector (pr, temp);
 
  // neuen view-vektor festlegen
  Normalize(SubtractVector (pr, vp), vd);
end;
 
// Rotate (ix,iy) or roll (iz) the camera about the focal point
procedure TCamera.RotateCamera(ix, iy, iz: TGLdouble);
var
  local_vu,local_vd,right: TGLvector;
  newvp,newr: TGLvector;
  radius: TGLdouble;
  dx,dy,dz: TGLdouble;
begin
  Normalize(vu, local_vu);
  Normalize(vd, local_vd);
  Normalize (CrossProduct (local_vd, local_vu), right);
 
  // Handle the roll
  if not (iz = 0) then
  begin
     vu.x := vu.x + iz * right.x;
     vu.y := vu.y + iz * right.y;
     vu.z := vu.z + iz * right.z;
     Normalize(vu, vu);
     exit;
  end;
 
  // Distance from the rotate point
  dx := vp.x - pr.x;
  dy := vp.y - pr.y;
  dz := vp.z - pr.z;
  radius := sqrt(dx*dx + dy*dy + dz*dz);
 
  // Determine the new position
  newvp.x := vp.x + ix*right.x + iy*local_vu.x - pr.x;
  newvp.y := vp.y + ix*right.y + iy*local_vu.y - pr.y;
  newvp.z := vp.z + ix*right.z + iy*local_vu.z - pr.z;
  Normalize(newvp, newvp);
  vp.x := pr.x + radius * newvp.x;
  vp.y := pr.y + radius * newvp.y;
  vp.z := pr.z + radius * newvp.z;
 
  // Get new right vector based on radius and current right
  newr.x := vp.x + right.x - pr.x;
  newr.y := vp.y + right.y - pr.y;
  newr.z := vp.z + right.z - pr.z;
  Normalize(newr, newr);
  newr.x := pr.x + radius * newr.x - vp.x;
  newr.y := pr.y + radius * newr.y - vp.y;
  newr.z := pr.z + radius * newr.z - vp.z;
 
  Normalize(SubtractVector (pr, vp), vd);
 
  // Determine the new up vector
  Normalize (CrossProduct (newr, vd), vu);
end;
 
// Move the camera to the home position
procedure TCamera.CameraHome;
var
  right,newr: TGLvector;
  radius: TGLdouble;
  local_vu,local_vd: TGLvector;
begin
  vp := vpInit;
  vd := vdInit;
  vu := vuInit;
  pr := vdInit;
 
  Normalize(vu, local_vu);
  Normalize(vd, local_vd);
  Normalize (CrossProduct (local_vd, local_vu), right);
 
  // Distance from the rotate point
  radius := Magnitude (SubtractVector(vp, pr));
 
  // Get new right vector based on radius and current right
  newr.x := vp.x + right.x - pr.x;
  newr.y := vp.y + right.y - pr.y;
  newr.z := vp.z + right.z - pr.z;
  Normalize(newr, newr);
  newr.x := pr.x + radius * newr.x - vp.x;
  newr.y := pr.y + radius * newr.y - vp.y;
  newr.z := pr.z + radius * newr.z - vp.z;
 
  Normalize(SubtractVector (pr, vp), vd);
 
  // Determine the new up vector
  Normalize (CrossProduct (newr, vd), vu);
end;
 
procedure TCamera.Apply;
var
  newMatrix: TArrMatrix;
begin
  if not Enabled then
    exit;
 
  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity();
  glDrawBuffer(GL_BACK_LEFT);
 
  gluLookAt(vp.X, vp.Y, vp.Z,
            pr.X, pr.Y, pr.Z,
            vu.X, vu.Y, vu.Z);
 
  glGetFloatv(GL_MODELVIEW_MATRIX, @newMatrix);
 
  CameraMatrix.Load(newMatrix);
end;
 
procedure TCamera.PositionCamera(PositionVec: TGLvector;
                                       ViewVec: TGLvector;
                                       upVec: TGLvector);
begin
  vpInit := PositionVec;
  vdInit := ViewVec;
  vuInit := UpVec;
 
  CameraHome;
 
  if not Initiated then
  begin
    SavePosition (1);
    Initiated := true;
  end;
end;
 
procedure TCamera.SavePosition (pos: integer);
begin
  if not Enabled then
    exit;
 
  if (pos < 0) or (pos > 9) then
    exit;
 
  vpArr[pos] := vp;
  vdArr[pos] := vd;
  vuArr[pos] := vu;
  prArr[pos] := pr;
end;
 
procedure TCamera.RestorePosition (pos: integer);
begin
  if not Enabled then
    exit;
 
  if (pos < 0) or (pos > 9) then
    exit;
 
  vp := vpArr[pos];
  vd := vdArr[pos];
  vu := vuArr[pos];
  pr := prArr[pos];
end;
 
destructor TCamera.Destroy;
begin
  CameraMatrix.Free;
end;
 
function TCamera.Position: TGLvector;
begin
  result.X := vp.X;
  result.Y := vp.Y;
  result.Z := vp.Z;
end;
 
function TCamera.ViewDirection: TGLvector;
begin
  result.X := pr.X;
  result.Y := pr.Y;
  result.Z := pr.Z;
end;
 
function TCamera.UpVector: TGLvector;
begin
  result.X := vu.X;
  result.Y := vu.Y;
  result.Z := vu.Z;
end;
end.

Nach oben

Flo

Betreff des Beitrags:

Verfasst: Di Okt 11, 2005 17:06

DGL Member

Registriert: Do Jun 19, 2003 10:44
Beiträge: 991
Wohnort: Karlsfeld (nahe München)

Wenn ich den Code da sehe muss ich erlich sagen du machst es dir viel zu schwer.

Wieso veränderst du die Kamara Matrix nicht einfach so:
* aktuelle Modellviewmatrix speichern
* Kamara Matrix laden
* glTranslate,glScalef oder auch glRoatef ausführen
* Kamara Matrix in der Variable abspeichern
* Modelviewmatrix von vorher wieder herstellen

die Position der Kamara erhälst du dann wie gesagt durch die vierte Spalte der Matrix. Die Koordiantenachsen !! nicht ebenen sind die Spalten der Martrix.

Daher ist dies keine Roationsmatrix:

1,1,0,0
0,1,0,0
0,0,1,0
0,0,0,1

sondern eine die das Bild nun ja komisch verzerrt

Schau einfach nacher mal bei den Mathematischen Tutorials vorbei:
http://www.delphigl.com/launcher.php?em=tutorials

MfG
Flo

_________________
Danke an alle, die mir (und anderen) geholfen haben.
So weit... ...so gut

Nach oben

Andyh

Betreff des Beitrags:

Verfasst: Mi Okt 12, 2005 08:59

DGL Member

Registriert: Do Jun 09, 2005 13:48
Beiträge: 117
Wohnort: Sankt Augustin

ich dachte, dass ich genau das mache. wenn man sich die prozeduren RotateRoundAxis und Offset ansieht, dann wird doch genau das durchgeführt. wenn ich dann ein Apply mache und die so errechnete Matrix einsetze, dann ändert sich leider mein Rotationspunkt nicht.

Nach oben

Flo

Betreff des Beitrags:

Verfasst: Mi Okt 12, 2005 15:22

DGL Member

Registriert: Do Jun 19, 2003 10:44
Beiträge: 991
Wohnort: Karlsfeld (nahe München)

Nicht ganz, du machst laut obrigen code folgendes(achte auf die eingefügten Kommentare):

Code:

 
procedure TCamera.Offset(x, y, z: TGLfloat);
var
  newMatrix: TArrMatrix;
begin
  // Eine 
Verschiebungs Matrix erzeugen
  glMatrixMode (GL_MODELVIEW);
  glPushMatrix();
  glLoadIdentity();
  glTranslatef(x,y,z);
  glGetFloatv(GL_MODELVIEW_MATRIX, @newMatrix);
 
  // Du multiplizierst sie von Hand anstat das OpenGL für dich machen zu lassen.
  // Da ich MatrixMultiply nicht kenne weis ich nicht ob du die Martrizen in der richtigen Reinfolge übergibst.
  MatrixMultiply(newMatrix,CameraMatrix.Matrix,newMatrix);
{...}
 

Wieso machst du das hier nicht so wie in RotateRoundAxis? Dann schleichen sich auch keine Fehler ein. Denn es macht sehrwohl einen unterschied ob man erst rotiert und dann verschiebt oder erst verschiebt und dann rotiert.

Lese dir dazu am besten mal das Tutorial von Flash zum Thema OpenGL Matrizen durch. Außerdem kann ich mich nur wiederholen in dem ich dir rate zumindest passende Mathematik Tutorials durchzulesen.
z.B.
Objekt gedreht und dennoch nach vorne bewegt
Objekt immer um eigene Achse drehen

Ich habe die zwar noch nicht gelesen aber rein vom Titel her müssten die für dich interessant sein.

MfG
Flo

_________________
Danke an alle, die mir (und anderen) geholfen haben.
So weit... ...so gut

Nach oben

Andyh

Betreff des Beitrags: einen versuch ist es wert

Verfasst: Do Okt 13, 2005 09:23

DGL Member

Registriert: Do Jun 09, 2005 13:48
Beiträge: 117
Wohnort: Sankt Augustin

ich denke schon, dass ich das mit der reihenfolge usw. richtig verstanden habe. In einem hast Du aber recht: ich werde mal versuchen die Matritzenmultiplikation von OpenGL durchführen zu lassen.

Danke.

Nach oben

Seite 1 von 1

[ 13 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.