Eigene 3D-Engine

[ISAS]

Hat jemand von euch schon eine eigene 3D-Engine programmiert? Eine sehr einfache und komplexe? Also nur so, das er einen 3D Punkt in 2D darstellen kann? Will mir nämlich mal den Quellcode dazu anschauen. Wollte selber mal ne Engine machen, aber irgendwie fehlte mir der oben genannte Punkt. Drehen, skaliere, etc ging alles, nur 3D wars nicht. Wenn vielleicht jemand den code posten könnte oder die File schicken, das wäre nett.

PS: Habe schon mal sowas gepostet, nur stimmte die Formel, die ich bekommen habe nicht ganz.

[Tubos]

Zitat:

Hat jemand von euch schon eine eigene 3D-Engine programmiert? Eine sehr einfache und komplexe? Also nur so, das er einen 3D Punkt in 2D darstellen kann?

Wenn man das darstellen und Berechnen der Punkte selbst programmiert, dann spricht man im allgemeinen von einem "Software-Renderer", da die Bildberechnung nicht von der Grafikkarte übernommen wird.

[Ben1]

Ob software- oder Hardwarerendern, 3D Engine ist beides. Aber zum Thema, alles was dir also fehlt ist die Projektionsmatrix bzw. -gleichung. Dafür gibt es wesentlich mehr als eine Lösung, ich empfehle dir mal nach einem Buch über OpenGL zu suchen. Die enthalten häufig auch einen Teil über die theoretischen Grundlagen, inclusive der mahtematischen Beschreibung verschiedener Projektionsgleichungen

[Kernel32.DLL]

Zitat:

Zitat von ISAS

Eine sehr einfache und komplexe?

Was denn nun? Einfach oder Komplex? :stupid:

[ISAS]

einfach natürlich! :wink:


Hat wirklich noch nie jemand eine gemacht?? :cry:

[Ben1]

Doch natürlich, nur sind die Möglichkeiten eine 3D/2D Projektion zu realisieren unglaublich vielfältig.
Ich nenne nur mal eine:

Du brauchst einen Vektor der angibt in welche Richtung du schaust X, einen für oben Z und einen für rechts Y(wobei sich natürlich aus 2 Vektoren der dritte automatisch ergibt), die Position P des Betrachters selbstverständlich auch.

Damit hast du drei Ebenen, x-y, x-z und y-z. Jetzt berechnest du den Abstand zwischen den Ebenen und dem Punkt den du darstellen willst.
Sagen wir mal
a = Abstand x-y Ebene;
b = Abstand x-z Ebene;
c = Abstand y-z Ebene;

Wenn c kleiner Null ist, kannste abbrechen da sich der Punkt eh hinter dir befindet. a enthält die y Koordinate auf dem Bildschirm und b die x Koordinate. Damit das ganze jetzt auch wie 3D aussieht kannst du die beiden bei bedarf noch durch ein vielfaches von c dividieren (je weiter weg desto kleiner :chat: ) Und, ganz wichtig, jetzt noch von x die halbe Bildschirmbreite und von y die halbe Bildschirmhöhe abziehen, um das Bild in die Mitte des Bildschirms zu kriegen.

Da schon 17 bist solltest du das bereits in der Schule gelernt haben.



Alternativ kannst du natürlich auch die entsprechende Matrix dafür hernehmen und alles mit einer einzigen Multiplikation erledigen. :warn:

[Darty]

Nein hab noch kein 3D Engine programmiert.
Eine 3D Engine ist nichts anderes als eine Schnittstelle die Sound, Grafik, Physik, und und und auswertet und ausgibt und was weiss ich alles.
Ich denke zu den Thema würde es wohl eher passen wenn du mal auf www.delphigl.com gehst. Ist nen OpenGL Seite und darunter befindet sich auch ein Tutorial Bombermania oder wie es sich nennt. So in der Richtung wird dann eine Engine aufgebaut.

[OregonGhost]

Wenn es dir um die Architektur der Engine geht, empfehle ich die Artikelserie Enginuity auf gamedev.net.
Wenn du Probleme mit der 3D-Mathematik hast, bietet dir möglicherweise das DirectX SDK für C++ eine gute Einstiegshilfe, denn dort wenn die meisten dieser Dinge erklärt (im Managed DirectX SDK wird diesbezüglich leider einiges unterschlagen).

Wenn es dir darum geht, einzelne Punkte darzustellen, solltest du dir vielleicht mal Point Sprites ansehen.

Eine gute OpenSource-3D-Engine ist Irrlicht.

Und wenn du was ganz anderes willst, solltest du es vielleicht nochmal genauer erklären :stupid:

[ISAS]

Genau gesagt:

Ich will die Mathematik dahinter, wie ein 3D Punkt 2D(auf dem Bildschirm) dargestellt werden kann.

Hab das nun von Ben versucht, aber das ging nicht :cry:

[Maximus]

Wenn du einen 3D Würfel auf den Monitor (2D) - z.B. mit Canvas - zeichnen willst, dann musst du für jeden der 8 Punkte X = X+0.5*Z und Y = Y+0.5*Z rechnen.

Aber irgendwie hab ich das Gefühl die Frage nicht verstanden zu haben :gruebel:

[ISAS]

Ich kann mich irren, aber bezieht sich diese Formel nicht auf eine 3D darstellung eines Würfels, wo der Linienwinkel, die nach hinten gehen, genau 45° betragen

[hboy]

Da ich mich nun auch zu denen zählen will die jedes rad selber erfinden wollen hab ich auch eine kleine 3D-Engine geschrieben, basierend nem happen Assembler und delphi code, einem bisschen canvas.
Kann 32bit texturen, z-bufferung und Alphablending ( MMX optimiert ;) aber noch nicht eingebunden ^^ ).
hab das projekt aber geparkt weil mir das restliche optimieren zu stressig war.
Denk dran, der Reiz an der Sache ist, es selber zu machen. versuch zu beginn erst mal beliebige polygone zweidimensional darzustellen. Dann hast dus schon fast !
Du willst code sehen ? tja... selbst is der programmierer ^^

[hboy]

achja ich hab das so hingezaubert

Delphi-Quellcode:

function transform3d(p: TPolygon):TPolygon;
var
  f1, f2, f3 : single;
  q: TPOlygoN;
const fov = 300;
begin




  // rotation

  q := p;

  q.a.x := round( p.a.x * cos(vp_a) + p.a.z * sin(vp_a));
  q.a.z := round( p.a.z * cos(vp_a) - p.a.x * sin(vp_a));
  q.b.x := round( p.b.x * cos(vp_a) + p.b.z * sin(vp_a));
  q.b.z := round( p.b.z * cos(vp_a) - p.b.x * sin(vp_a));
  q.c.x := round( p.c.x * cos(vp_a) + p.c.z * sin(vp_a));
  q.c.z := round( p.c.z * cos(vp_a) - p.c.x * sin(vp_a));

  p :=q;

  q.a.z := q.a.z+ vp_org.z;
  q.b.z := q.b.z+ vp_org.z;
  q.c.z := q.c.z+ vp_org.z;

  q.a.x := round( p.a.x * cos(vp_b)   + p.a.y * sin(vp_b));
  q.a.y := round( p.a.y * cos(vp_b)   - p.a.x * sin(vp_b));
  q.b.x := round( p.b.x * cos(vp_b)   + p.b.y * sin(vp_b));
  q.b.y := round( p.b.y * cos(vp_b)   - p.b.x * sin(vp_b));
  q.c.x := round( p.c.x * cos(vp_b)   + p.c.y * sin(vp_b));
  q.c.y := round( p.c.y * cos(vp_b)   - p.c.x * sin(vp_b));


  // projektion
  f1 := fov/(max(10,(fov+q.a.z)));   // d/b
  f2 := fov/(max(10,(fov+q.b.z)));
  f3 := fov/(max(10,(fov+q.c.z)));

  result.a.x := screenXC + round((q.a.x + vp_org.x)*f1);
  result.b.x := screenXC + round((q.b.x + vp_org.x)*f2);
  result.c.x := screenXC + round((q.c.x + vp_org.x)*f3);

  result.a.y := screenYC - round((q.a.y + vp_org.y)*f1);
  result.b.y := screenYC - round((q.b.y + vp_org.y)*f2);
  result.c.y := screenYC - round((q.c.y + vp_org.y)*f3);


  result.a.z := q.a.z+fov;
  result.b.z := q.b.z+fov;
  result.c.z := q.c.z+fov;



end;

sollte noch dazu sagen: result kriegt die tatsächlichen Bildschirmkoordinaten und als z-wert die berechneten z-werte zum interpolieren ( z-buffer)

[Ben1]

Code:

Hab das nun von Ben versucht, aber das ging nicht

Wie, was ging nicht ?
Natürlich geht das! Habs doch selbst mal in jungen Jahren so gemacht!
Wichtig ist natürlich das die Vektoren ein kartesisches Rechtssystem bilden und man sich nicht irgendwo verrechnet. Aber dann geht das garantiert!

[rantanplan99]

Hi,

ich hab mal uralten Sourcecode rausgekramt .. 10 Jahre alt *G* Damals noch in Trubo Pascal für DOS, und das mal nach Delphi portiert .. gab natürlich Probleme weil die Datentypen jetzt alle größer sind und ich das umpflügen musste, jetzt hauts aber hin, aber nicht alle Routinen sind Delphi kompatibel gemacht *g*

Das Programm lädt die 3D Object beschreibung aus Box.3D und stellt den Würfel dar. Die 3D --> 2D Projektion erfolgt aber nicht mathematisch, sondern ignoriert einfach die Z Koordinate.

Und bitte nehmt mich jetzt nicht auseinander weil der Sourcecode aussieht wie hingesch***** ... der ist wirklich von 1995.

rantanplan

[-NIP-]

Zitat:

Zitat von Maximus

, dann musst du für jeden der 8 Punkte X = X+0.5*Z und Y = Y+0.5*Z rechnen.

Wie kann man bitte einen Wert errechnen, den man den nur errechnen kann, wenn man den Wert schon kennt?
Bitte nicht übel nehmen, ich bin erst in der 9. Klasse.


Und:
Wenn die Z-Koordinate ausgelassen wird, ist es ja nicht 3d. ;)

-NIP-

[Ben1]

Zitat:

X = X+0.5*Z

Hier gibt es zwei X'se, einmal die Pixelkoordinate X und dann noch die Vektorkomponente X. Etwas undeutlich in der Formel.

Zitat:

Wenn die Z-Koordinate ausgelassen wird, ist es ja nicht 3d.

Stimmt nicht. Dein Bildschirm kann nichts dreidimensionales darstellen, er ist nunmal flach (mehr oder weniger), die Tiefe fällt immer weg. Hier geht um die Projektion eines 3D Objektes auf eine Fläche und in dem Zusammenhang ist das schlichte nich beachten der Z-Komponete durchaus eine, wenn auch sehr primitive, Methode.

[hboy]

naja ich sag nix mehr dazu ...

[hboy]

mh doch zwei sachen ^^
erstens is zur Zeit Abistress auf der Speisekarte , zweitens zu meinem Codeschnipsel:
vp ist Viewport

vp_a ist der Winkel um die Hochachse, eigentlich fehlt noch vp_g also gamma damit ich alle drei winkel drin hab, hab ich aber noch nicht so weit gebraucht, und achja vp_org ist der origin also der Ursprung des Viewports. ScreenXC und YC sind die werte der Bildschirmmitte

und gute nacht :)