3D Spiel

[Corpsman]

@ Cöster

Tutorials gibts da leider keins, zumindest kenne ich keine.

Balanced ist nicht mein erstes Spiel das ich schreibe, von daher habe ich schon ein wenig erfahrung im Leveleditor schreiben gehabt.

Ich fange eigentlich immer gleich an.

Als erstes wird ne Klasse TLevel gebastelt.

Delphi-Quellcode:

Type TLevel = Class
      Private
      Public
     end;

Dann überlege ich mir was für ein Leveltyp ich haben will und wie ich die elemente im Level speichere, was für Proceduren Tlevel unbedingt haben mus und welche auf keinen Fall.

Im 2D- Bereich habe ich da bisher fast immer 2D-Arrays als Platzhalter der Koordinaten genommen.

In Balanced ( 3D ) habe ich Dynamische Arrays gemacht, da ein 3D-Array in den größen die es in meinem Game gibt ziemlich gewaltig werden würde.

Als nächsten wichtigen Punkt das Zeichnen / Rendern

Tlevel mus auf alle Fälle eine Zeichen Routine haben die du von deiner Anwendung aufrufen kannst ohne dir gedanken machen zu müssen.

D.h. in Balanced gibts Tlevel.render die Rendert mir dann einfach alles was es zum Level gibt.

Der Leveleditor beginnt dann schnell zu wachsen. Ich bin beim Balanced Leveleditor ja immer noch nicht fertig. Immer wieder baue ich neue Elemente ein.

Weitere Proceduren die es dann so gibt sind in Ballanced :

Delphi-Quellcode:

    ..
    Procedure DeleteObject(x, y, z: integer);
    Procedure RotateCoord(x, y, z, Angle: integer);
    Procedure Render;
    Procedure RenderSky;
    Procedure SaveToFile(Filename: String; viewer: Tviewer; Cursor3d: TCursor3d; bc: Boolean); // Still Gelegt
    Procedure SaveToFile2(Filename: String; viewer: Tviewer; Cursor3d: TCursor3d; bc: Boolean);
    Procedure LoadFromFile(Filename: String; Var viewer: Tviewer; Var Cursor3d: TCursor3d; Var BC: Boolean); // Still Gelegt
    Procedure LoadFromFile2(Filename: String; Var viewer: Tviewer; Var Cursor3d: TCursor3d; Var BC: Boolean);
    Procedure Loadhighscores(Filename: String);
    Procedure ClearLevel;
    Procedure Setnewton(Const Newtonworld: Pnewtonworld);
    Procedure UnsetNewton(Const Newtonworld: Pnewtonworld);
    Procedure Collision(PlayerPos: TVector3f; PlayerMat: shortint);
    Procedure Restart(Const Newtonworld: Pnewtonworld);
    Procedure ResetLevel(Const Newtonworld: Pnewtonworld);
    Procedure resetHighscore;
    Procedure setBarierGroup(ID: Gluint; Const Newtonworld: Pnewtonworld);
    Procedure SetCoordText(x, y, z: integer; Value: String);
    Function Coordid(x, y, z: integer): String;
    ..

Wie du sehen kannst gibts jede menge I/O schnittstellen. Ganz zu schweigen von den 96 Add Proceduren die ich hier mal nicht kopiert habe um den Post nicht unnötig auf zu blähen.

Ich hoffe das gibt euch eine Grobe Idee, für weitere Fragen stehe ich natürlich gerne zur verfügung.

[Cöster]

Danke für den Einblick in deine Level-Editoren. Wenn ich dich richtig verstehe, speicherst du die Welt also 3-dimensional in Arrays und zur Darstellung rechnest du sie dann wahrscheinlich unter Berücksichtigung von Blickwinkel und Kameraposition in ein 2D-Bild um, welches du dann immer wieder neu auf dem Bildschirm. Ist das korrekt oder wie schaffst du die Darstellung?

[Corpsman]

@ Cöster

NEIN,

Wenn ich das so machen würde wärs heftig.

1. Speichere ich nur die Opbjecte diese sind alle in einem eindimensionalen Array gespeichert.
Jedes Element hat eine Variable Position. Für alle neugierigen hier die Basisklasse von der alle Objecte im spiel abgeleitet wurden.

Delphi-Quellcode:

  TBalancedObject = Class
  private
    FTexture: GLuint; // Pointer auf die Graphik unseres Steines.
    Fposition: TVector3f;
    FSchwerpunkt: TVector3f;
    Fpoints: Array Of TVector3f;
    Froty: Integer;
    Function FgetRotationY: integer;
    Procedure Setschwerpunkt;
  public
    Property RotationY: integer read FgetRotationY;
    Property Texture: gluint read Ftexture;
    Function Position: TVector3f;
    Constructor create(Pointcount: Integer);
    Destructor destroy; override;
    Procedure RotateY(Angle: Integer); virtual;
  End;

Und alles was zum Zeichnen benutzt wird macht OpenGL für mich.

D.h. seit dem Frustumculling nicht mehr alles, aber fast.( für einen Anfänger macht man alles und versteht irgendwann wie's geht und baut dann das Frustumculling ein, oder so)

was du mit Blickwinkel und gruscht meinst bruache ich nicht machen.

OpenGL ist genau wie Form1.canvas

Es gibt Zeichenroutinen die benutze ich, nur eben das alles 3D ist.

Den ganzen Optischen gruscht macht dann das OpenGL für mich.

Das Rendern eines Rechtecks passiert bei mir im Spiel z.b. so

Delphi-Quellcode:

Procedure DrawQuadPolygon(LeftTop, RightTop, RightBottom, LeftBottom: TVector3f; Texture: gluint = 0);
Begin
  // Einbinden der Graphik
  If Texture <> 0 Then
    glBindTexture(GL_TEXTURE_2D, Texture);
  // Öffnen des Quad Modus
  glbegin(GL_QUADS);
  // Zeichnen Links unten
  glTexCoord2f(0.0, 0.0);
  glVertex3f(LeftBottom.X, LeftBottom.y, LeftBottom.z);
  // Zeichnen Rechts unten
  glTexCoord2f(1.0, 0.0);
  glVertex3f(RightBottom.X, RightBottom.y, RightBottom.z);
  // Zeichnen Rechts Oben
  glTexCoord2f(1.0, 1.0);
  glVertex3f(RightTop.X, RightTop.y, RightTop.z);
  // Zeichnen Links Oben
  glTexCoord2f(0.0, 1.0);
  glVertex3f(LeftTop.X, LeftTop.y, LeftTop.z);
  // Beenden des Quad Modus
  glend;
End;

Wenn man es ganz scharf betrachtet kann man die Procedure DrawQuadPolygon schon als Engine Bezeichnen.

[vlees91]

Zitat von Cöster:

Wenn du in dem Buch einiges nicht verstanden hast, könnte das ja vielleicht auch daran liegen, dass du aufgrund deines Alters die erforderlichen mathematischen Kenntnisse in der Schule noch nicht hattest. Ich weiß jetzt nicht, wann genau Trigonometrie in der Schule drankommt, aber bei mir war's glaub ich erst in der 10. Klasse, und Vektor-Rechnung hatte ich selbst auch noch nicht (bin jetzt in der 12. Klasse).

Naja es lag ganz sicher nicht an der Mathematik, denn ich habe auch ohne etwas mit dem buch zu tun in OpenGL (nicht glscene oder was anderes fertiges) sogar selber die ganzen sachen hergeleitet um in 1st person zu bewegen (kamera dreht direkt) drehen (und anderes bewegeung) und auch in 3rd person (kamera dreht um einen punkt in der mitte, der aber auch relativ ist) (... hatte kein internet um das alles zu kopieren...), und das war KEIN problem.

[Cöster]

@Corpsman:
Mit 1 Jahr Schuldelphi und ansonsten keinerlei Programmiererfahrung ist das wohl noch nix führ mich. Vielleicht sollte ich mir erstmal auf http://delphigl.com/ ein paar Tutorials zur Materie durchlesen und dann guck ich auch in diesen Thread nochmal rein. Aber jetzt mach ich wohl erstmal meine 2D-Spiele fertig. Trotzdem danke für die Tipps, sie werden mir später sicherlich nochmal helfen.

@vlees91:
Was wär denn konkret so ein Beispiel, bei dem das Buch deiner Meinung nach nicht genug erklärt hat?

[inherited]

Hm, ich weiß nicht, ich hab ja selbst die bücher empfohlen. Klar ist bei glScene der einstieg leichter, aber(ich finde) man hat bei genesis3d später wesentlich mer möglichkeiten. Von Mathematischer seite her hatte ich keine großen Probleme.

[Nils_13]

Genesis ist einfach nur schwer. Irrlicht ist viel leichter, wenn man einen Wrapper hat.