DGL • Thema anzeigen - Spiel programmieren

Spiel programmieren - Fragen

Moderator: DGL-Team

Seite 2 von 2

[ 17 Beiträge ]

Gehe zu Seite Vorherige 1, 2

Vorheriges Thema | Nächstes Thema

Autor

Nachricht

Müllermilchtrinker

Betreff des Beitrags: Re: Spiel programmieren - Fragen

Verfasst: Sa Apr 09, 2011 13:40

DGL Member

Registriert: Mo Aug 23, 2010 19:45
Beiträge: 16
Programmiersprache: Delphi und noch mehr

*ausgrab*
So hab das Programm ein wenig vergessen und da wir jetzt Vektoren im Unterricht angefangen haben, dachte ich mir, ich kann das doch mal fertig machen. Nur stehe ich mal wieder vor einem Problem. Mein Rechteck (also das Auto) will sich nicht bewegen.

Also hier meine Unit:

Code:

 
unit Unit1;
 
interface
 
uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, ExtCtrls, dglOpenGL, StdCtrls, Vektor;
 
type
  TForm1 = class(TForm)
    panOpenGL: TPanel;
    Label1: TLabel;
    Label2: TLabel;
    procedure FormCreate(Sender: TObject);
    procedure FormDestroy(Sender: TObject);
    procedure IdleHandler(Sender: TObject; var Done: Boolean);
    procedure FormKeyDown(Sender: TObject; var Key: Word; Shift: TShiftState);
  private
    { Private-Deklarationen }
    StartTime, TimeCount, FrameCount  : Cardinal; //FrameCounter
    Frames, DrawTime                  : Cardinal; //& Timebased Movement
    procedure SetupGL;
    procedure Render;
    procedure ErrorHandler;
    procedure Init;
  public
    { Public-Deklarationen }
    DC                                : HDC;  //Handle auf Zeichenfläche
    RC                                : HGLRC;//Rendering Context
  end;
 
var
  Form1: TForm1;
  x1,y1,x2,y2,z1:real;
//  TexCar : glUInt;
//  TexSzenario: glUInt;
  timeElapsed,angle, acceleration: Single;
  positioncar,velocity,temp: TVector;
 
const
  NearClipping = 0.1;
  FarClipping  = 100;
 
implementation
 
{$R *.dfm}
 
// FormCreate
procedure TForm1.FormCreate(Sender: TObject);
begin
  DC:= GetDC(panOpenGL.Handle);
  if not InitOpenGL then Application.Terminate;
  RC:= CreateRenderingContext( DC,
                               [opDoubleBuffered],
                               32,
                               24,
                               0,0,0,
                               0);
  ActivateRenderingContext(DC, RC);
  SetupGL;
  Init;
  Application.OnIdle := IdleHandler;
end;
 
// FormDestroy
procedure TForm1.FormDestroy(Sender: TObject);
begin
  DeactivateRenderingContext;
  DestroyRenderingContext(RC);
  ReleaseDC(Handle, DC);
end;
 
//KeyDown
procedure TForm1.FormKeyDown(Sender: TObject; var Key: Word;
  Shift: TShiftState);
begin
  case key of
    39: begin angle := angle - 1 * timeElapsed;
              if angle < 0 then angle := angle + 2*PI; end;       //Pfeiltaste rechts
    37: begin angle := angle + 1 * timeElapsed;
              if angle > 2*PI then angle := angle - 2*PI; end;       //Pfeiltaste links
    40: acceleration := acceleration - 1;       //Pfeiltaste nach unten
    38: acceleration := acceleration + 1;       //Pfeiltaste nach oben
    87: y2 := y2 + 0.1;       //w                       -   Szenario nach oben
    65: x2 := x2 - 0.1;       //a                       -   Szenario nach links
    83: y2 := y2 - 0.1;       //s                       -   Szenario nach unten
    68: x2 := x2 + 0.1;       //d                       -   Szenario nach rechts
    69: z1 := z1 + 0.01;       //e                       -   Reinzoomen
    81: z1 := z1 - 0.01;       //q                       -   Rauszoomen
  end;
end;
 
// Setup - OpenGL
procedure TForm1.SetupGL;
begin
  glClearColor(0.0, 0.0, 0.0, 0.0); //Hintergrundfarbe:
  glEnable(GL_DEPTH_TEST);          //Tiefentest aktivieren
  glEnable(GL_CULL_FACE);           //Backface Culling aktivieren
 
  glEnable(GL_BLEND) ;
  glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
end;
 
// Init - OpenGL
procedure TForm1.Init;
begin
//  LoadTexture(ExtractFilePath(ParamStr(0))+'auto.tga', TexCar, False);
//  LoadTexture(ExtractFilePath(ParamStr(0))+'\Texturen\straße.tga', TexSzenario, False);
  positioncar.MakeVector(0,0,0);
  velocity.MakeVector(0,0,0);
  temp.MakeVector(0,0,0)
end;
 
// Render - OpenGL
procedure TForm1.Render;
begin
  glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);
 
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity;
  gluPerspective(90.0, panOpenGL.ClientWidth/panOpenGL.ClientHeight, NearClipping, FarClipping);
  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity;
 
  glTranslatef(0+x2, 0+y2, -3+z1);
 
  glBegin(GL_QUADS);
    // Beschleunigung ausführen
    velocity.x := velocity.x + acceleration * timeElapsed * sin(angle);
    velocity.y := velocity.y + acceleration * timeElapsed * cos(angle);
 
    // Bewegung ausführen
    temp.ScaleVector(velocity , timeElapsed);
    positioncar.AddVectors(positioncar , temp);
 
    glTexCoord2f(0,0); glVertex3f(0+positioncar.x, 0+positioncar.y, 0);
    glTexCoord2f(0,1); glVertex3f(1+positioncar.x, 0+positioncar.y, 0);
    glTexCoord2f(1,1); glVertex3f(1+positioncar.x, 2+positioncar.y, 0);
    glTexCoord2f(1,0); glVertex3f(0+positioncar.x, 2+positioncar.y, 0);
 
 
    //Ursprung setzen
    glColor3f(1, 0, 0); glVertex3f(0, 0, 0);
    glColor3f(0, 1, 0); glVertex3f(0.5, 0, 0);
    glColor3f(0, 0, 1); glVertex3f(0.5, 0.5, 0);
    glColor3f(1, 1, 0); glVertex3f(0, 0.5, 0);
  glEnd;
 
  SwapBuffers(DC);
end;
 
// ErrorHandle - OpenGL
procedure TForm1.ErrorHandler;
begin
  Label2.Caption := string(gluErrorString(glGetError));
end;
 
// IdleHandle - OpenGL
procedure TForm1.IdleHandler(Sender: TObject; var Done: Boolean);
begin
  StartTime:= GetTickCount;
  Render;
  DrawTime:= GetTickCount - StartTime;
  timeElapsed := drawtime;
  Inc(TimeCount, DrawTime);
  Inc(FrameCount);
 
  if TimeCount >= 1000 then begin
    Frames:= FrameCount;
    TimeCount:= TimeCount - 1000;
    FrameCount:= 0;
    Label1.Caption:= InttoStr(Frames) + ' FPS';
    ErrorHandler;
  end;
  Done:= false;
end;
 
end.
 

Und hier meine Unit Vektoren:

Code:

 
unit Vektor;
 
interface
 
uses
  dglOpenGL;
 
 type
   TVector = record
    X : Single; //Dasselbe wie TGLFloat
    Y : Single;
    Z : Single;
    function MakeVector(X, Y,Z : Single) : TVector;
    function AddVectors(VectorA, VectorB : TVector) : TVector;
    function SubVectors(VectorA, VectorB : TVector) : TVector;
    function Magnitude(Vector : TVector) : Single;
    procedure Normalize(var Normal : TVector);
    function ScaleVector(Vector : TVector; Multi : Single) : TVector;
    function DotProduct(VectorA,VectorB : TVector) : Single;
    function CrossProduct(VectorA,VectorB : TVector) : TVector;
//    TTriangle = array[0..2] of TVector;
//    function GetNormal(Triangle : TTriangle) : TVector;
  end;
 
implementation
 
function TVector.MakeVector(X,Y,Z : Single) : TVector;
begin
  result.x := x;
  result.y := y;
  result.z := z;
end;
 
function TVector.AddVectors(VectorA, VectorB : TVector) : TVector;
begin
  {Einfache Vektoraddition}
  Result := MakeVector(VectorA.X + VectorB.X,
                       VectorA.Y + VectorB.Y,
                       VectorA.Z + VectorB.Z);
end;
 
function TVector.SubVectors(VectorA, VectorB : TVector) : TVector;
begin
  {Einfache Vektorsubtraktion}
  Result := MakeVector(VectorA.X - VectorB.X,
                       VectorA.Y - VectorB.Y,
                       VectorA.Z - VectorB.Z);
end;
 
function TVector.Magnitude(Vector : TVector) : Single;
begin
  {Gibt die Länge (Betrag) eines Vektors zurück}
   result := sqrt(Vector.X * Vector.X+
                  Vector.Y * Vector.Y+
                  Vector.Z * Vector.Z);
end;
 
procedure TVector.Normalize(var Normal : TVector);
var
  Length : Single;
begin
  {Der angegebene Vektor wird auf eine Länge (Betrag) von 1 gekürzt,
   um dies zu erreichen muss jede Vektorkomponente durch die Länge
   (Betrag) des Vektors selbst dividiert werden }
  Length := Magnitude(Normal);
  if (Length = 0) then Length := 1;//Wir wollen keine Division durch 0
  Normal.X := Normal.X / Length;
  Normal.Y := Normal.Y / Length;
  Normal.Z := Normal.Z / Length;
end;
 
function TVector.ScaleVector(Vector : TVector; Multi : Single) : TVector;
begin
  { Der Vektor wird skaliert mit dem angegeben Faktor Multi }
  { Dies ändert nicht die Richtung des Vektors! }
  result.x := Vector.x * Multi;
  result.y := Vector.y * Multi;
  result.z := Vector.z * Multi;
end;
 
function TVector.DotProduct(VectorA,VectorB : TVector) : Single;
begin
  {Das Ergebnis des Punktprodukts ist der Kosinus des Winkels
   zwischen den beiden Vektoren, wenn Vektor A und Vektor B normalisiert
   wurden, ansonsten muss man das Punktprodukt noch durch die Längen
   der Vektoren teilen.
 
   Ist der Kosinus positiv, dann ist der Winkel kleiner 90°, ist der
   Kosinus negativ dann ist der Winkel größer 90°. Benutze den ArcusKosinus
   um den Winkel aus den Werten zwischen -1 und 1 wieder in Grad-Bogenmaß
  (Rad) zu erhalten. }
 
   result := VectorA.X*VectorB.X+
             VectorA.Y*VectorB.Y+
             VectorA.Z*VectorB.Z;
end;
 
function TVector.CrossProduct(VectorA,VectorB : TVector) : TVector;
begin
  {Erzeugt einen Vektor der senkrecht zur Fläche ist,
   die durch die zwei gegeben Vektoren erzeugt wurde }
 
   Result.X := VectorA.Y*VectorB.Z - VectorA.Z*VectorB.Y;
   Result.Y := VectorA.Z*VectorB.X - VectorA.X*VectorB.Z;
   Result.Z := VectorA.X*VectorB.Y - VectorA.Y*VectorB.X;
end;
 
//function TTriangle.GetNormal(Triangle : TTriangle) : TVector;
//var
//  VectorA, VectorB, Normal : TVector;
//begin
//  {To get the normal we first need to define a plane.
//   To do this we use the three vertices to create two
//   vectors, thereby defining a plane. If we give these
//   two vectors to the CrossProduct function we get a
//   vector that is perpendicular to the plane in return.
//   All we then need to do is cut this vector to a length
//   of 1 and we have our normal.}
//
// { Um die Normale zu erhalten müssen wir als erstes
//   eine Fläche festlegen. Um dies zu erreichen benutzen
//   wir die drei Eckpunkte um zwei Vektoren zu erhalten.
//   Wenn wir diese Vektoren der Punktprodukt Funktion
//   übergeben, bekommen wir einen Vektor zurück der
//   Senkrecht zur Fläche ist. Alles was wir dann noch
//   machen müssen ist den Vektor auf eine Länge von 1
//   zu kürzen und wir erhalten unseren Normalenvektor. }
//
//   VectorA := SubVectors(Triangle[0],Triangle[1]);
//   VectorB := SubVectors(Triangle[1],Triangle[2]);
//   Normal := CrossProduct(VectorA,VectorB);
//   Normalize(Normal);
//   result := Normal;
//end;
 
end.
 

Zuletzt geändert von Lord Horazont am Sa Apr 09, 2011 13:45, insgesamt 1-mal geändert.

Codetags zu delphi geändert

Nach oben

Markus

Betreff des Beitrags: Re: Spiel programmieren - Fragen

Verfasst: Sa Apr 09, 2011 15:55

DGL Member

Registriert: Fr Mär 30, 2007 18:35
Beiträge: 331

Wenn ich das richtig sehe, liegt es an Folgendem:

Code:

    // Beschleunigung ausführen
    velocity.x := velocity.x + acceleration * timeElapsed * sin(angle);
    velocity.y := velocity.y + acceleration * timeElapsed * cos(angle);
 
    // Bewegung ausführen
    temp.ScaleVector(velocity , timeElapsed);
    positioncar.AddVectors(positioncar , temp);

Das ganze liegt daran, dass deine Vektor-Klasse ziemlich "komisch" ist. Wieso sind alle Vektoroperationen Methoden, obwohl sie nicht von "self"-Objekt abhängig sind? Du könntest "ScaleVector" und konsorten als normale Funktionen deklarieren.

Daher kommt auch dein Fehler: temp.ScaleVector(velocity , timeElapsed); verändert nicht temp, sondern hat im Rückgabewert den neuen Vektor. Danach addierst du temp zu positioncar, temp hat sich aber nicht verändert. EDIT: Du machst nichtmal das, auch der Wert der Addition ist im Rückgabewert, positioncar verändert sich auch nicht.

Nach oben

Seite 2 von 2

[ 17 Beiträge ]

Gehe zu Seite Vorherige 1, 2

Foren-Übersicht » Programmierung » Einsteiger-Fragen

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.