DGL • Thema anzeigen - Cameramovement

Cameramovement

Moderator: DGL-Team

Seite 1 von 2

[ 18 Beiträge ]

Gehe zu Seite 1, 2 Nächste

Vorheriges Thema | Nächstes Thema

Autor

Nachricht

Shaddow

Betreff des Beitrags: Cameramovement

Verfasst: Sa Mär 01, 2008 15:47

DGL Member

Registriert: So Aug 20, 2006 23:19
Beiträge: 564

Hi,
ich habe seit einer Weile wieder mal Zeit zum Programmieren und habe so nach und nach meine Todoliste im Projekt abgearbeitet.

Tja und nun stehe ich wiedermal vor meinem Prob, dass ich schon seit nem guten Jahr habe, immer wieder in Angriff nehme und dann aus Verzweiflung doch wieder fallen lasse...
Ich versuche es also wiedereinmal:

Meine Camera besitzt zwei Pfade:
Ein Pfad bezeichnet die Bewegung der Camera.
Der zweite Pfad bezeichnet, wolang die Camera schaut.

Beide Pfade besitzen eine Geschwindigkeit und sind durch eine Kette von Vektoren gekennzeichnet.
Wenn ich die Applikation nun starte, soll die Kamera sich auf dem MovePath bewegen (Translation) und immer auf den richtigen Punkt im LookPath schauen (Rotation).

Die Bewegung funktioniert einwandfrei, nur sobald ich den LookPath einschalte, dreht sich die Kamera wild in irgendwelche Richtungen.
Hier mal der Quellcode:

Code:

procedure TSE_Camera.Update;
var distance, nX, nY,
    r, delta, phi: Single;
    v1: TGLVectorf3;                        
begin
  case fMoveMode of
    mmFree:
    begin
          // nothing
    end;
 
    mmPath:
    begin
      distance := MMSpeed * Renderer.CurTime/1000;
      if distance > MovePath.PathLength then
      begin
        fMoveMode := mmFree;
        fLookMode := lmFree;
      end;
      Translation := MovePath.GetPos(distance);
    end;
 
    mmAttachedToObject:
    begin
 
    end;
 
    mmCircleAroundObject:
    begin
 
    end;
  end;
 
  case fLookMode of
    lmFree:
    begin
          // nothing
    end;
 
    lmPath:
    begin
      distance := LMSpeed * Renderer.CurTime/1000;
      v1 := SubtractVector(LookPath.GetPos(distance),Translation);
      WriteLn(floattostr(v1[0])+' '+floattostr(v1[1])+' '+floattostr(v1[2]));
 
 
//// HIER hab ich mal Kugelkoordinaten versucht, ging aber im Grunde auch nicht /////
{
      r := LengthofVector(v1);
      phi := arctan(v1[X]/v1[Z]);
      delta := arccos(v1[Y]/r);
 
      if v1[Z]=0 then phi := sign(v1[X])*PI/2
      else if v1[Z] < 0 then
      begin
        if v1[X] < 0 then phi := phi - PI
        else phi := phi + PI;
      end;
        Rotation[Y] := phi/DEG2RAD;
        Rotation[X] := delta/DEG2RAD;
}
/// ENDE Kugelkoordinaten
      
 
      nX := DotProductVector(v1,Unite(v1[X],0,v1[Z])) / (LengthOfVector(v1)*LengthOfVector(Unite(v1[X],0,v1[Z])));
      nY := DotProductVector(v1,Unite(0,v1[Y],v1[Z])) / (LengthOfVector(v1)*LengthOfVector(Unite(0,v1[Y],v1[Z])));
 
      nX := Arccos(nX)/DEG2RAD;
      nY := Arccos(nY)/DEG2RAD;      
 
 
          Rotation[X] :=   nX; 
 
          Rotation[Y] :=   nY; 
    end;
 
    lmAsObject:
    begin
 
    end;
 
    lmAtObject:
    begin
 
    end;
  end;
  Frustum.Calculate;
end;

Wie man im Quellcode sieht, habe ichs auch schonmal ueber Kugelkoordinaten mit hilfe eines Tuts versucht, aber das hat nicht so funktioniert, wie ich das gern gehabt hätte.
Die andere Methode hab ich mir selbst mit meinem spärlichen Wissen über Vektoren zusammengeschußtert.

Beide funktionieren wie gesagt nicht richtig. Ich wäre äußerst dankbar fuer einen Lösungsansatz - dabei ist es mir gleich, ob es sich um Lösung für eine der beiden oben genannten Ansätz oder einen völlig neuen handelt.

Bitte - ich kann die hilfe echt brauchen

Nach oben

damadmax

Betreff des Beitrags:

Verfasst: Sa Mär 01, 2008 22:42

DGL Member

Registriert: Sa Aug 18, 2007 18:47
Beiträge: 694
Wohnort: Köln
Programmiersprache: Java

hast du dir mal die Funktion gluLookAt angesehen?

_________________
Es werde Licht.
glEnable(GL_LIGHTING);
Und es ward Licht.

Zitat aus einem Java Buch: "C makes it easy to shoot yourself in the foot; C++ makes it harder, but when you do it blows your whole leg off"

on error goto next

Nach oben

Shaddow

Betreff des Beitrags:

Verfasst: Mo Mär 03, 2008 15:58

DGL Member

Registriert: So Aug 20, 2006 23:19
Beiträge: 564

Jap hab ich, hatte ich auch schon, is ja auch im grunde eine sehr einfache lösung.

Das problem, was ich damit jedes mal hatte, war, dass ich meine Kamera logischerweise auch manuell, also von einem Pfad losgelöst, sich bewegen lassen können will. Ich klicke also irgendwo mit der Maus, halte die Taste gedrueckt und drehe mich. Da muesste ich permanent einen neuen Punkt im Raum ausrechnen, auf den ich gucke und das alles nur aus den X und Y Koordinaten auf die ich die Maus ziehe.

Da müsste ich ja irgendwie mit eine Projekt/Unprojektfunktion arbeiten, aber ich weiss partout nicht, wie ich auf diesen neuen Lookat punkt kommen soll..

Danke schonmal

Nach oben

Sidorion

Betreff des Beitrags:

Verfasst: Mo Mär 03, 2008 16:48

DGL Member

Registriert: Mo Dez 20, 2004 08:58
Beiträge: 442
Wohnort: Mittweida (Sachsen)

Na das ist doch der Kummer kleinster. Du hast nen Kamerapunkt und ne Blickrichtung. Danach ist der Center punkt Positionsvektor+Richtungsvektor. Die Länge der Richtung spielt hierbei keine Rolle.

_________________
Manchmal sehen Dinge, die wie Dinge aussehen wollen, mehr wie Dinge aus, als Dinge.
<Esmerelda Wetterwax>
Es kann vorkommen, dass die Nachkommen trotz Abkommen mit ihrem Einkommen nicht auskommen und umkommen.

Nach oben

Shaddow

Betreff des Beitrags:

Verfasst: Di Mär 04, 2008 12:26

DGL Member

Registriert: So Aug 20, 2006 23:19
Beiträge: 564

das ist es ja. ich habe keine blickrichtung ^^

Nach oben

Sidorion

Betreff des Beitrags:

Verfasst: Di Mär 04, 2008 13:10

DGL Member

Registriert: Mo Dez 20, 2004 08:58
Beiträge: 442
Wohnort: Mittweida (Sachsen)

wieso? die ergibt sich doch aus der Mausbewegung. Aktueller Punkt-MouseDown Punkt=Blickrichtung.

Nach oben

Shaddow

Betreff des Beitrags:

Verfasst: Di Mär 04, 2008 13:25

DGL Member

Registriert: So Aug 20, 2006 23:19
Beiträge: 564

ja aber ich bewege die maus nach links/rechts und oben/unten also habe ich lediglich einen X und einen Y wert. ich habe keinen 3 dimensionalen wert, dann waer das ja alles einfach. aber ich muss jetz praktisch mit diesem x und y wert eine richtung errechnen und das ist eben ziemlich schwer

Nach oben

damadmax

Betreff des Beitrags:

Verfasst: Di Mär 04, 2008 19:25

DGL Member

Registriert: Sa Aug 18, 2007 18:47
Beiträge: 694
Wohnort: Köln
Programmiersprache: Java

glRotate reicht da vollkommen.

Ich benutze sowas hier:

Code:

procedure TForm1.SetCamera(Translate: Boolean);
begin
  glRotatef(XRot, 1, 0, 0);
  glRotatef(YRot, 0, 1, 0);
  glRotatef(ZRot, 0, 0, 1);
  if Translate then
    glTranslatef(-Position[0], -Position[1], -Position[2]);
end;
 

Wobei ZRot meist auf 0 ist.

Die Rotationswerte werden im OnMouseMove Event aus der Differenz der Mausposition zwischen diesem und dem letzten Frame errechnet.

Wenn ich mich nun z.B. per WASD im Raum bewege. Wird ein Vector zusammengesetzt z.B. für Vorwärts

Code:

Richtung := Vector(0,0,-1);

bzw. jede Komponente einzeln, damit man mehrere Tasten gleichzeitig drücken kann.

Code:

Richtung.Z := -1;

Anschliessend mit Vector-drehenden Funktionen um die gleichen Rotationswerte gedreht und inklusive timebased-movement auf die aktuelle Position addiert.

Nach oben

Shaddow

Betreff des Beitrags:

Verfasst: Mi Mär 05, 2008 12:44

DGL Member

Registriert: So Aug 20, 2006 23:19
Beiträge: 564

ja so hatte ich das auch irgendwann schonmal, aberr ich will ja jetz glulookat verwenden, da will ich jetz nich wieder rotates und translates dazwischen haun. Ich möchte im Grunde nur wissen, wie ich auf den neuen Centerpoint komme.

Meine Theorie ist ja, dass ich den Richtungsvektor zwischen eye und dem alten center ausrechne, und dann um die x und y achse drehe, denn winkel bekomme ich ja, ueber die mausbewegung. Nur weiss ich eben nicht, wie genau ich diese Drehung eines Vektors um einen Winkle realisiere.

Nach oben

MatReno

Betreff des Beitrags:

Verfasst: Mi Mär 05, 2008 12:55

DGL Member

Registriert: Mo Jan 31, 2005 11:02
Beiträge: 432
Wohnort: Rheinlandpfalz

Hallo,
hier hab ich ein paar Funktionen, mit denen du einen beliebigen Vektor um die X-, Y-, oder Z-Achse drehen kannst.
Außerdem kannst du mit der ersten Funktion einen Vektor um einen beliebigen anderen Vektor drehen.
Alpha ist der Winkel in Grad.

Code:

Function VectorRotEVector(const vector, EVector: TVector3f; alpha: Single): TVector3f;
Var DSinAlpha, DCosAlpha: Single;
Begin
  DSinAlpha := DSin(alpha);
  DCosAlpha := DCos(alpha);
 
  Result:= ToVector3f( (DCosAlpha + sqr(EVector[0]) * (1 - DCosAlpha))                      * vector[0]  +  (EVector[0] * EVector[1] * (1 - DCosAlpha) - EVector[2] * DSinAlpha) * vector[1]  +  (EVector[0] * EVector[2] * (1 - DCosAlpha) + EVector[1] * DSinAlpha) * vector[2],
                       (EVector[0] * EVector[1] * (1 - DCosAlpha) + EVector[2] * DSinAlpha) * vector[0]  +  (DCosAlpha + sqr(EVector[1]) * (1 - DCosAlpha))                      * vector[1]  +  (EVector[1] * EVector[2] * (1 - DCosAlpha) - EVector[0] * DSinAlpha) * vector[2],
                       (EVector[0] * EVector[2] * (1 - DCosAlpha) - EVector[1] * DSinAlpha) * vector[0]  +  (EVector[1] * EVector[2] * (1 - DCosAlpha) + EVector[0] * DSinAlpha) * vector[1]  +  (DCosAlpha + sqr(EVector[2]) * (1 - DCosAlpha))                      * vector[2]
                     );
End;
 
Function VectorRotXVector(const vector: TVector3f; alpha: Single): TVector3f;
Begin
  Result := ToVector3f( vector[0],
                        DCos(alpha)*vector[1] - DSin(alpha)*vector[2],
                        DSin(alpha)*vector[1] + DCos(alpha)*vector[2]
                      );
End;
 
Function VectorRotYVector(const vector: TVector3f; alpha: Single): TVector3f;
Begin
  Result := ToVector3f( DCos(alpha)*vector[0] + DSin(alpha)*vector[2],
                        vector[1],
                        -DSin(alpha)*vector[0] + DCos(alpha)*vector[2]
                      );
End;
 
Function VectorRotZVector(const vector: TVector3f; alpha: Single): TVector3f;
Begin
  Result := ToVector3f( DCos(alpha)*vector[0] - DSin(alpha)*vector[1],
                        DSin(alpha)*vector[0] + DCos(alpha)*vector[1],
                        vector[2]
                      );
End;

wo DSin = Sin(DegToRad(angle)) und DCos = Cos(DegToRad(angle))

Ich hoffe das hilft dir!

_________________
http://texelviews.delphigl.com

Nach oben

Sidorion

Betreff des Beitrags:

Verfasst: Mi Mär 05, 2008 14:19

DGL Member

Registriert: Mo Dez 20, 2004 08:58
Beiträge: 442
Wohnort: Mittweida (Sachsen)

Hab auch noch ein paar nette Funktionen für Dich:Damit kannst Du die Kamera um die angegebenen Winkel rotieren lassen. Die Angaben sind die Winkel um die Achsen Z (Rolle) , X (Looping) und Y (Kurve), bezogen auf Kamera.

Code:

Procedure TCamera.Rotate(_dForward,_dRight,_dUp: GLdouble);
Var
  oDirForward: TGLVector;
  oMatForward: TGLMatrix;
  oDirRight: TGLVector;
  oMatRight: TGLMatrix;
  oDirUp: TGLVector;
  oMatUp: TGLMatrix;
  oDirection: TGLVector;
Begin
  oDirection:=VecSub(oCenter,oEye);
  oDirForward:=VecNormalize(oDirection);
  oDirRight:=VecMultX(oDirForward,oUp);
  oDirUp:=VecMultX(oDirRight,oDirForward);
  If _dForward<>0
  Then Begin
    oMatForward:=VecToRotationMatrix(oDirForward,_dForward);
    oDirection:=vecMult(oDirection,oMatForward);
  End;
  If _dRight<>0
  Then Begin
    oMatRight:=VecToRotationMatrix(oDirRight,_dRight);
    oDirection:=vecMult(oDirection,oMatRight);
  End;
  If _dUp<>0
  Then begin
    oMatUp:=VecToRotationMatrix(oDirUp,_dUp);
    oDirection:=vecMult(oDirection,oMatUp);
  End;
  oCenter:=vecAdd(oEye,oDirection);
End;
 

Dies dient der Rotation der Kamera um sich selber. oCenter, oEye und oUp sind Member meiner Kameraklasse und entsprechen den Parametern für gluLookAt
Hierzu noch ein paar Hilfsfunktionen:

Code:

 
//______________________________________________________________________________
Function MakeVector(_dX,_dY,_dz: GLDouble): TGLVector;
Begin
  Result.X:=_dX;
  Result.Y:=_dY;
  Result.Z:=_dZ;
End;
//______________________________________________________________________________
Function ToRad(_dArcDegree: GLdouble): GLdouble;
Begin
  Result:=_dArcDegree / 180 * Pi;
End;
//______________________________________________________________________________
Function ToDeg(_dArcRad: GLdouble): GLdouble;
Begin
  Result:=_dArcRad *180 / Pi;
End;
//______________________________________________________________________________
Function VecAdd(_oSummand1: TGLVector;_oSummand2: TGLVector): TGLVector;
Begin
  Result:=MakeVector(_oSummand1.X+_oSummand2.X,
                     _oSummand1.Y+_oSummand2.Y,
                     _oSummand1.Z+_oSummand2.Z);
End;
//______________________________________________________________________________
Function VecSub(_oMinuend: TGLVector;_oSubtrahend: TGLVector): TGLVector;
Begin
  Result:=MakeVector(_oMinuend.X-_oSubtrahend.X,
                     _oMinuend.Y-_oSubtrahend.Y,
                     _oMinuend.Z-_oSubtrahend.Z);
End;
//______________________________________________________________________________
Function VecScale(_oVector: TGLVector;_dScalar: GLdouble): TGLVector;
Begin
  Result:=MakeVector(_oVector.X*_dScalar,
                     _oVector.Y*_dScalar,
                     _oVector.Z*_dScalar);
End;
//______________________________________________________________________________
Function VecMult(_oVector1: TGLVector;_oVector2: TGLVector): GLdouble;
Begin
   result := _oVector1.X*_oVector2.X+
             _oVector1.Y*_oVector2.Y+
             _oVector1.Z*_oVector2.Z;
End;
//______________________________________________________________________________
Function VecMult(_oVector: TGLVector;_oMatrix: TGLMatrix): TGLVector;
Begin
  Result.X:=_oMatrix.M[0,0]*_oVector.X+
            _oMatrix.M[1,0]*_oVector.Y+
            _oMatrix.M[2,0]*_oVector.Z+
            _oMatrix.M[3,0];
  Result.Y:=_oMatrix.M[0,1]*_oVector.X+
            _oMatrix.M[1,1]*_oVector.Y+
            _oMatrix.M[2,1]*_oVector.Z+
            _oMatrix.M[3,1];
  Result.Z:=_oMatrix.M[0,2]*_oVector.X+
            _oMatrix.M[1,2]*_oVector.Y+
            _oMatrix.M[2,2]*_oVector.Z+
            _oMatrix.M[3,2];
End;
//______________________________________________________________________________
Function VecMultX(_oVector1: TGLVector;_oVector2: TGLVector): TGLVector;
Begin
  Result:=MakeVector(_oVector1.Y*_oVector2.Z - _oVector1.Z*_oVector2.Y,
                     _oVector1.Z*_oVector2.X - _oVector1.X*_oVector2.Z,
                     _oVector1.X*_oVector2.Y - _oVector1.Y*_oVector2.X)
End;
//______________________________________________________________________________
Function VecNormalize(_oVector: TGLVector): TGLVector;
Var
  dLength: GLdouble;
Begin
  dLength:=Magnitude(_oVector);
  If dLength=0 Then dLength:=1;
  Result:=VecScale(_oVector,1/dLength);
End;
//______________________________________________________________________________
Function VecToRotationMatrix(_oAxis: TGLVector;
                             _dRotation: GLDouble): TGLMatrix;
Var
  c: Double;
  s: Double;
Begin
  c:=cos(_dRotation);
  s:=sin(_dRotation);
  Result.M[0,0]:=c + (1-c)*sqr(_oAxis.X);
  Result.M[0,1]:=(1-c)*_oAxis.X*_oAxis.Y + s*_oAxis.Z;
  Result.M[0,2]:=(1-c)*_oAxis.Z*_oAxis.X - s*_oAxis.Y;
  Result.M[0,3]:=0;
 
  Result.M[1,0]:=(1-c)*_oAxis.X*_oAxis.Y - s*_oAxis.Z;
  Result.M[1,1]:=c + (1-c)*sqr(_oAxis.Y);
  Result.M[1,2]:=(1-c)*_oAxis.Y*_oAxis.Z + s*_oAxis.X;
  Result.M[1,3]:=0;
 
  Result.M[2,0]:=(1-c)*_oAxis.Z*_oAxis.X + s*_oAxis.Y;
  Result.M[2,1]:=(1-c)*_oAxis.Y*_oAxis.Z - s*_oAxis.X;
  Result.M[2,2]:=c + (1-c)*sqr(_oAxis.Z);
  Result.M[2,3]:=0;
 
  Result.M[3,0]:=0;
  Result.M[3,1]:=0;
  Result.M[3,2]:=0;
  Result.M[3,3]:=1;
End;
 

Ach ja, ein paar Typen noch:

Code:

  TGLMatrix=Record
    Case Boolean of
      True: (A: Array[0..15] of GLDouble);
      False: (M: Array[0..3,0..3] of GLDouble);
    // ATTENTION OpenGL stores Column-leading
    // first index is Column, second is Row
    // e.g.: 1st col, 3rd row would be [0,2] not [2,0]
  End;
  TGLVector=Record
   Case Integer Of
    0: (X: GLDouble;
        Y: GLDouble;
        Z: GLDouble);
    1: (Width: GLDouble;
        Depth: GLDouble;                                     
        Height: GLDouble);
    2: (Tilt: GLDouble;
        Roll: GLDouble;
        Pan: GLDouble);
  End;
 

Nach oben

Shaddow

Betreff des Beitrags:

Verfasst: Fr Mär 07, 2008 12:42

DGL Member

Registriert: So Aug 20, 2006 23:19
Beiträge: 564

ok mit matrenos funktionen funktioniert es.

Ich habe nur ein Problem noch. Wenn ich mich nach links/rechts drehe, dann drehe ich mich ja immer um die Y-Achse, deswegen kann ich das fest reinprogrammieren.

Wenn ich aber gewissermaßen meinen Kopf nach oben und Unten neige, drehe ich mich um eine Achse, abhaengig von meiner Position udn meiner Blickrichtung.

Hab mir das mal theoretisch ueberlegt:

Die Achse, um die ich mich drehe, ist eine Normale zu meiner Blickrichtung (Center - Eye) und der Y-Achse (0,1,0). Nun muesste ich ja nur um diese Achse Rotieren. Mein Code dazu sieht so aus:

Code:

 
 // subtract vector subtrahiert automatisch den zweiten vom ersten vector
// Rotation um Y -Achse -> funktioniert
     Center := RotateVectorY(SubtractVector(Eye,Center), XRel*DEG2RAD/10);
// rotation um errechnete Achse -> funktioniert nicht, wie sie soll
      Center := RotateVector(SubtractVector(Eye,Center),CrossProductVector(SubtractVector(Eye,Center),Unite(0,1,0)), YRel*DEG2RAD/10);
 
 

Nach oben

Shaddow

Betreff des Beitrags:

Verfasst: Mo Mär 10, 2008 16:03

DGL Member

Registriert: So Aug 20, 2006 23:19
Beiträge: 564

hat hier wer der mathematisch etwas versierteren eine idee?

Nach oben

damadmax

Betreff des Beitrags:

Verfasst: Mo Mär 10, 2008 18:11

DGL Member

Registriert: Sa Aug 18, 2007 18:47
Beiträge: 694
Wohnort: Köln
Programmiersprache: Java

Du rotierst immer um Y? Dann bau dir aus "SubtractVector(Eye,Center)" und dem Vektor (0,1,0) über ein Kreuzprodukt die Achse, die "quer" durch deine Kamera geht. Sprich: Die X-Achse im Ortho-modus. Dann kannst du mit 'VecToRotationMatrix' um diese Achse rotieren.

Wenn ich jetzt nich alles total verpeilt habe

Nach oben

Shaddow

Betreff des Beitrags:

Verfasst: Di Mär 11, 2008 09:35

DGL Member

Registriert: So Aug 20, 2006 23:19
Beiträge: 564

Naja im Grunde mache ich ja genau, was du da beschreibst:

Ich baue ein KreuzProdukt aus SubtractVector(Eye,Center) und Unite(0,1,0) => CrossProductVector(SubtractVector(Eye,Center),Unite(0,1,0)
und dann rotiere ich meinen Vektor daherum => Center := RotateVector(SubtractVector(Eye,Center),CrossProductVector(SubtractVector(Eye,Center),Unite(0,1,0)), YRel*DEG2RAD/10); Bei RotateVector ist der erste Vektor der zu rotierende, der zweite ist der Vektor, um den Rotiert wird und der letzte Wert ist der Winkel

Nach oben

Seite 1 von 2

[ 18 Beiträge ]

Gehe zu Seite 1, 2 Nächste

Foren-Übersicht » Programmierung » Mathematik-Forum

Wer ist online?

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