DGL • Thema anzeigen - mal wieder camera (mit Kameraklasse)

mal wieder camera (mit Kameraklasse)

Moderator: DGL-Team

Seite 1 von 1

[ 1 Beitrag ]

Vorheriges Thema | Nächstes Thema

Autor

Nachricht

Andyh

Betreff des Beitrags: mal wieder camera (mit Kameraklasse)

Verfasst: Sa Okt 01, 2005 17:05

DGL Member

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

Hallo,

und schon wieder bin ich am Ende mitt meinen Nerven...

Ich habe eine Kameraklasse gebastelt, die sher gut funktioniert. Es gibt allerdings ein kleines, wenn auch sehr
nerviges Problem. Die Kamera kann um alle Achsen drehen und in allen Dimensionen bewegt werden. Die Szene
bewegt sich auch sehr schön, wie erwartet. das Problem ist, dass ich den Rotationspunkt nicht bewegen kann.
Obwohl ich pr (siehe Codebeispiel) beim bewegen (Translatecamera) immer neu berechne, bleibt dieser blöde
Punkt immer fix an der durch PositionCamera festgelegten Stelle. Es ist zum Haareraufen. Kann mir vielleicht
jemand hier aus der Patsche helfen?

Die benutzten funktionen (CrossProduct, Mormalize, ... und der verwendete Datentyp TGLvector) dürfte so oder
in anderer Form in Eueren Programmen wohl auch vorkommen. Deswegen habe ich die Deklarationen nicht
beigefügt. Die sind in meiner Unit OpenGLUtil deklariert.

Im Voraus vielen Dank,

Andy

Code:

 
unit Camera;
 
interface
 
  Uses DglOpenGL, OpenGLUtil, Windows, Classes;
 
  type TCamera = class
    pr       : TGLvector;        // rotation point
    vp       : TGLvector;        // Camera Position
    vu       : TGLvector;        // View Up
    Enabled  : boolean;
    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;
  private
    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;
  end;
  TPCamera=^TCamera;
 
implementation
 
uses KanalUtil;
 
{ TCamera }
 
constructor TCamera.Create;
var
  i: integer;
begin
  Enabled := false;
  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;
end;
 
// Rotate (ix,iy) or roll (iz) the camera about the focal point
procedure TCamera.RotateCamera(ix, iy, iz: TGLdouble);
var
  l_vp,l_vu,l_vd,right: TGLvector;
  newvp,newr: TGLvector;
  radius: TGLdouble;
  dx,dy,dz: TGLdouble;
begin
  Normalize(vu, l_vu);
  l_vp := vp;
  Normalize(vd, l_vd);
 
  right := CrossProduct (l_vd, l_vu);
  Normalize (right, 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 := l_vp.x + ix * right.x + iy * l_vu.x - pr.x;
  newvp.y := l_vp.y + ix * right.y + iy * l_vu.y - pr.y;
  newvp.z := l_vp.z + ix * right.z + iy * l_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;
 
  vd.x := pr.x - vp.x;
  vd.y := pr.y - vp.y;
  vd.z := pr.z - vp.z;
  Normalize(vd,vd);
 
  // Determine the new up vector
  vu := CrossProduct (newr, vd);
  Normalize (vu, vu);
end;
 
// Move the camera to the home position
procedure TCamera.CameraHome;
var
  right,newr: TGLvector;
  radius: TGLdouble;
  l_vu,l_vd: TGLvector;
  dx,dy,dz: TGLdouble;
begin
  vp := vpInit;
  vd := vdInit;
  vu := vuInit;
  pr := vdInit;
 
  Normalize(vu, l_vu);
  Normalize(vd, l_vd);
 
  right := CrossProduct (l_vd, l_vu);
  Normalize (right, right);
  // 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);
 
  // 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;
 
  vd.x := pr.x - vp.x;
  vd.y := pr.y - vp.y;
  vd.z := pr.z - vp.z;
  Normalize(vd,vd);
 
  // Determine the new up vector
  vu := CrossProduct (newr,vd);
  Normalize (vu, vu);
end;
 
// Translate (pan) the camera view point
procedure TCamera.TranslateCamera(ix, iy, iz: TGLdouble);
var
  l_vd, l_vu, newr, right: TGLvector;
begin
  right := CrossProduct(vd,vu);
  Normalize (right, right);
 
  vp.x := vp.x + (iy*vu.x + ix*right.x + iz*vd.x);
  vp.y := vp.y + (iy*vu.y + ix*right.y + iz*vd.y);
  vp.z := vp.z + (iy*vu.z + ix*right.z + iz*vd.z);
 
  pr.x := pr.x + (iy*vu.x + ix*right.x + iz*vd.x);
  pr.y := pr.y + (iy*vu.y + ix*right.y + iz*vd.y);
  pr.z := pr.z + (iy*vu.z + ix*right.z + iz*vd.z);
 
  vd.x := pr.x - vp.x;
  vd.y := pr.y - vp.y;
  vd.z := pr.z - vp.z;
  Normalize(vd,vd);
end;
 
procedure TCamera.Apply;
var
  viewX, viewY, viewZ: TGLdouble;
begin
  if not Enabled then
    exit;
 
  viewX := vp.X + vd.X;
  viewY := vp.Y + vd.Y;
  viewZ := vp.Z + vd.Z;
 
  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity();
  glDrawBuffer(GL_BACK_LEFT);
 
  gluLookAt(vp.X, vp.Y, vp.Z,
            viewX, viewY, viewZ,
            vu.X, vu.Y, vu.Z);
end;
 
procedure TCamera.PositionCamera(PositionVec: TGLvector;
                                       ViewVec: TGLvector;
                                       upVec: TGLvector);
begin
  vpInit := PositionVec;
  vdInit := ViewVec;
  vuInit := UpVec;
 
  CameraHome;
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;
 
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.