DGL • Thema anzeigen - gluLookAt und Upvector

gluLookAt und Upvector

Moderator: DGL-Team

Seite 1 von 1

[ 1 Beitrag ]

Vorheriges Thema | Nächstes Thema

Autor

Nachricht

Andyh

Betreff des Beitrags: gluLookAt und Upvector

Verfasst: Mo Aug 15, 2005 03:24

DGL Member

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

Hallo, hallo,

ich habe mir eine camera Klasse von einem anderen Programmierer geklaut und in mein Programm integriert. Diese Klasse hält die von gluLookAt benötigten Informationen bereit und verändert sie je nach Benutzerwunsch. Wird gluLookAt mit diesen Informationen aufgerufen, dann sollte sich immer die richtige Ansicht darbieten.

Informationen: Kameraposition, Blickrichtung und Upvector.

Die von dieser Klasse bereitgestellten Funktionen sind das bewegen der Kamere links/rechts, des zoomen der Kamera in den Bildschirm und wieder heraus und das drehen der Kamera um jede beliebige Achse.

Ich bin allerdings zu der Ansicht gelangt, dass das drehen der Kamera um die Achsen nie richtig ausprobiert oder getestet wurde. Bei einem Upvector 0,1,0 funktioniert die Drehung um die Y-Achse, bei einem Upvector von 1,0,0 um die X-Achse und bei einem Upvector von 0,0,1 um die Z-Achse. Habe ich den Upvector immer gleich (bei mir 0,1,0), stellt sich die Drehung nicht rund dar sondern unsymmetrisch. Ausserdem kippt die Drehung bei einem bestimmten Punkt um 180°.

Man muss den Upvector also auch anpassen und nicht nur die Kameraposition oder die Blickrichtung neu berechnen.

Ich habe auch schon einige Hinweise darauf gefunden, aber keine richtige Anleitung.

Kann mir vielleicht jemand sagen wie ich den Upvector anpassen muss bei

1. einer Drehung der Kameraposition um einen Punkt
2. eine Drehung des Blickpunktes um die Kamera
3. einer Bewegung der Kamera hoch/runter (an der Y-Achse entlang)

Das wäre super,

Danke

Hier die Klasse:

Code:

 
// die aus meiner unit OpenGLUtil benötigten definitionen:
type
  TGLVector = packed record
    x,y,z: GLfloat;
  end;
 
// die kameraklasse
unit CameraClass;
 
interface
 
  Uses DglOpenGL, OpenGLUtil, Windows, Classes;
 
  type TCamera = object
    Position : TGLvector;      // The camera's position
    View     : TGLvector;      // The camera's View
    UpVector : TGLvector;      // The camera's UpVector
    procedure PositionCamera(PositionVec: TGLvector;
                                   ViewVec: TGLvector;
                                   upVec: TGLvector);
    procedure RotateView(const X, Y, Z : glFloat);
    procedure MoveCameraByMouse(MouseX, MouseY,
                                MiddleX, MiddleY: integer);
    procedure RotateAroundPoint(const Center : TGLvector;
                                const X, Y, Z : glFloat);
    procedure PanCamera(speed : glFloat);   // schwenken der kamera links/rechts
    procedure LiftCamera(speed : glFloat);    // nach oben/unten bewegen
    procedure ZoomCamera(speed : glFloat);// in den bildschirm rein/aus dem bildschirm raus
  end;
 
  var SCREEN_WIDTH, SCREEN_HEIGHT : Integer;
 
implementation
 
{ TCamera }
 
{------------------------------------------------------------------------}
{--- This function sets the camera's position and view and up vVector ---}
{------------------------------------------------------------------------}
procedure TCamera.PositionCamera(PositionVec: TGLvector;
                                       ViewVec: TGLvector;
                                       upVec: TGLvector);
begin
  Position.X := PositionVec.X;
  Position.Y := PositionVec.Y;
  Position.Z := PositionVec.Z;
 
  View.X     := ViewVec.X;
  View.Y     := ViewVec.Y;
  View.Z     := ViewVec.Z;
 
  UpVector.X := UpVec.X;
  UpVector.Y := UpVec.Y;
  UpVector.Z := UpVec.Z;
end;
 
{-----------------------------------------------------------------------------}
{--- This will move the camera forward or backward depending on the speed  ---}
{-----------------------------------------------------------------------------}
procedure TCamera.ZoomCamera(speed: glFloat);
var V : TGLvector;
begin
  // Get our view vVector (The direciton we are facing)
  V.X := View.X - Position.X;              // This gets the direction of the X
  V.Y := View.Y - Position.Y;              // This gets the direction of the Y
  V.Z := View.Z - Position.Z;              // This gets the direction of the Z
 
  Position.X := Position.X + V.X * speed;  // Add our acceleration to our position's X
  Position.Y := Position.Y + V.Y * speed;  // Add our acceleration to our position's Y
  Position.Z := Position.Z + V.Z * speed;  // Add our acceleration to our position's Z
 
  View.X := View.X + V.X * speed;          // Add our acceleration to our view's X
  View.Y := View.Y + V.Y * speed;          // Add our acceleration to our view's Y
  View.Z := View.Z + V.Z * speed;          // Add our acceleration to our view's Z
end;
 
{-----------------------------------------------------------}
{--- The mouse look function. Use mouse to look around   ---}
{-----------------------------------------------------------}
{procedure TCamera.ZoomCameraByMouse;
var mousePos : TPoint;
    middleX, middleY : Integer;
    deltaY, rotateY : glFloat;
begin
  middleX := SCREEN_WIDTH SHR 1;       // This is a binary shift to get half the width
  middleY := SCREEN_HEIGHT SHR 1;      // This is a binary shift to get half the height
 
  // Get the mouse's current X,Y position
  GetCursorPos(mousePos);
 
  // If our cursor is still in the middle, we never moved... so don't update the screen
  if (mousePos.X = middleX) AND (mousePos.Y = middleY) then
    exit;
 
  // Set the mouse position to the middle of our window
  SetCursorPos(middleX, middleY);
 
  // Get the direction the mouse moved in, but bring the number down to a reasonable amount
  rotateY := (middleX - mousePos.X)/500;
  deltaY  := (middleY - mousePos.Y)/1000;
 
  // Multiply the direction vVector for Y by an acceleration (The higher the faster is goes).
  View.Y := View.Y + deltaY*5;
 
  // Check if the distance of our view exceeds 60 from our position, if so, stop it. (UP)
  if View.Y - Position.Y > 10 then
     View.Y := Position.Y + 10;
 
  // Check if the distance of our view exceeds -60 from our position, if so, stop it. (DOWN)
  if View.Y - Position.Y < -10 then
     View.Y := Position.Y - 10;
 
  // Here we rotate the view along the X avis depending on the direction (Left of Right)
  RotateView(0, -rotateY, 0);
end;}
procedure TCamera.MoveCameraByMouse (MouseX, MouseY,
                                     MiddleX, MiddleY: integer);
// ich musste die mausfunktionen dieser neuen funktion vorlagern, sonst
// geht es halt nicht. die werte werden jetzt als parameter übergeben, die in
// der prozedur BewegeKameraDurchMaus erfasst werden.
var
  deltaY, rotateY : glFloat;
begin
  // Get the direction the mouse moved in, but bring the number down to a reasonable amount
  rotateY := (MiddleX - MouseX)/500;
  deltaY  := (MiddleY - MouseY)/1000;
 
  // Multiply the direction vVector for Y by an acceleration (The higher the faster is goes).
  View.Y := View.Y + deltaY*500;
 
  // Check if the distance of our view exceeds 60 from our position, if so, stop it. (UP)
  //if View.Y - Position.Y > 60 then
  //  View.Y := Position.Y + 60;
 
  // Check if the distance of our view exceeds -60 from our position, if so, stop it. (DOWN)
  //if View.Y - Position.Y < -60 then
  //   View.Y := Position.Y - 60;
 
  // Here we rotate the view along the Y avis depending on the direction (Left of Right)
  RotateView(0, -rotateY, 0);
end;
 
{---------------------------------------------------------------------}
{--- This pans the camera left and right depending on the speed ---}
{---------------------------------------------------------------------}
procedure TCamera.PanCamera(speed: glFloat);
var
  Cross, ViewVector : TGLvector;
begin
  // Get the view vVector of our camera and store it in a local variable
  ViewVector := SubtractVector (View, Position);
 
  // Calculate the cross product of our up vVector and view vVector
  Cross := CrossProduct (UpVector, ViewVector);
 
  // Add the resultant vVector to our position
  Position.X := Position.X + Cross.X * speed;
  Position.Z := Position.Z + Cross.Z * speed;
 
  // Add the resultant vVector to our view
  View.X := View.X + Cross.X * speed;
  View.Z := View.Z + Cross.Z * speed;
end;
 
{---------------------------------------------------------------------}
{--- This lifts the camera up and down depending on the speed      ---}
{---------------------------------------------------------------------}
procedure TCamera.LiftCamera(speed: glFloat);
var
  Cross, ViewVector: TGLvector;
begin
  // Get the view vVector of our camera and store it in a local variable
  ViewVector := SubtractVector (View, Position);
 
  // Calculate the cross product of our up vVector and view vVector
  Cross := CrossProduct (UpVector, ViewVector);
 
  // Add the resultant vVector to our position
  Position.Y := Position.Y + Cross.Y * speed;
  Position.Z := Position.Z + Cross.Z * speed;
 
  // Add the resultant vVector to our view
  View.Y := View.Y + Cross.Y * speed;
  View.Z := View.Z + Cross.Z * speed;
end;
 
{-----------------------------------------------------------}
{--- This rotates the view around the position           ---}
{-----------------------------------------------------------}
procedure TCamera.RotateView(const X, Y, Z: glFloat);
{
var
  viewVector : TGLvector;
begin
  // Get our view vVector (The direction we are facing)
  viewVector.X := View.X - Position.X; // This gets the direction of the X
  viewVector.Y := View.Y - Position.Y; // This gets the direction of the Y
  viewVector.Z := View.Z - Position.Z; // This gets the direction of the Z
 
  // If we pass in a negative X Y or Z, it will rotate the opposite way,
  // so we only need one function for a left and right, up or down rotation.
  if X <> 0 then
  begin
    View.Z := Position.Z + sin(X)*viewVector.Y + cos(X)*viewVector.Z;
    View.Y := Position.Y + cos(X)*viewVector.Y - sin(X)*viewVector.Z;
  end;
 
  if Y <> 0 then
  begin
    View.Z := Position.Z + sin(Y)*viewVector.X + cos(Y)*viewVector.Z;
    View.X := Position.X + cos(Y)*viewVector.X - sin(Y)*viewVector.Z;
  end;
 
  if Z <> 0 then
  begin
    View.X := Position.X + sin(Z)*viewVector.Y + cos(Z)*viewVector.X;
    View.Y := Position.Y + cos(Z)*viewVector.Y - sin(Z)*viewVector.X
  end;
}
var
  vVector : TGLvector;
  Sinus, Cosinus, Mult: single;
    oldUp: TGLvector;
begin
  oldUp := UpVector;
  //InitVector (UpVector);
  Mult := 1{2*pi/360};
 
  // Get our view vVector (The direction we are facing)
  vVector := SubtractVector (View, Position);
 
  // If we pass in a negative X Y or Z, it will rotate the opposite way,
  // so we only need one function for a left and right, up or down rotation.
  if X <> 0 then
  begin
    Cosinus := cos (x*Mult);
    Sinus := sin(x*Mult);
    //UpVector.x := 1;
    View.Z := Position.Z + Sinus*vVector.Y + Cosinus*vVector.Z;
    View.Y := Position.Y + Cosinus*vVector.Y - Sinus*vVector.Z;
  end
  else if Y <> 0 then
  begin
    Cosinus := cos (y*Mult);
    Sinus := sin(y*Mult);
    //UpVector.y := 1;
    View.Z := Position.Z + Sinus*vVector.X + Cosinus*vVector.Z;
    View.X := Position.X + Cosinus*vVector.X - Sinus*vVector.Z;
  end
  else if Z <> 0 then
  begin
    Cosinus := cos (z*Mult);
    Sinus := sin(z*Mult);
    //UpVector.z := 1;
    View.X := Position.X + Sinus*vVector.Y + Cosinus*vVector.X;
    View.Y := Position.Y + Cosinus*vVector.Y - Sinus*vVector.X
  end;
end;
 
procedure TCamera.RotateAroundPoint(const center: tglvector;
                                    const x,y,z: TGLfloat);
var
    PosViewVector: TGLvector;
begin
  // Get the viewVector from our position to the center we are rotating around
  PosViewVector := SubtractVector (Position, Center);
 
  // Rotate the position up or down, then add it to the center point
  if X <> 0 then
  begin
    Position.Z := Center.Z + sin(X)*PosViewVector.Y + cos(X)*PosViewVector.Z;
    Position.Y := Center.Y + cos(X)*PosViewVector.Y - sin(X)*PosViewVector.Z;
  end
  else if Y <> 0 then
  begin
    Position.Z := Center.Z + sin(Y)*PosViewVector.X + cos(Y)*PosViewVector.Z;
    Position.X := Center.X + cos(Y)*PosViewVector.X - sin(Y)*PosViewVector.Z;
  end
  else if Z <> 0 then
  begin
    Position.X := Center.X + sin(Z)*PosViewVector.Y + cos(Z)*PosViewVector.X;
    Position.Y := Center.Y + cos(Z)*PosViewVector.Y - sin(Z)*PosViewVector.X;
  end;
end;
end.
 

Nach oben

Seite 1 von 1

[ 1 Beitrag ]

Foren-Übersicht » Programmierung » Mathematik-Forum

Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder und 2 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.