4. OpenGL - ein Objekt zeichnen (Quader), bäuchte Hilfe !!!!!

OpenGL - ein Objekt zeichnen (Quader), bäuchte Hilfe !!!!!

  • P

    Hey Leute,
    also ich hab ja mit OpenGL anefangen, und bin jetzt an den Zeichen Operationen angekommen.
    Doch i-wie möcht ich des nicht so recht verstehen.
    Hab mich eine ganze Nacht durchs Internet gejagt und nichts drüber gefunden was es gut erklärt.
    Deswegen frag ich hier noch mal nach :
    Also ich möcht ein einfaches Quadrat zeichnen.
    Ok, und hier liegt auch schon mein Problem.
    Nämlich :

    glVertex3f( 1.0f, 1.0f,-1.0f);

    Ich verstehe jetzt nicht was die einzelnen Zahlen bedeiten.

    Steht das jetzt so für da ? :
    [code]glVertex3f( x , y , z) ????
    Und welches Längenmaß haben jetzt genau die 1.0f ?????
    Währe super dankbar für eine kleine Definition im Code.
    Also ich hab mal versucht so eine kleine Skizze anzufertigen, und ich hoff das sie auch richtig ist :

    http://img518.imageshack.us/img518/7356/openglperspektivejq6.th.jpg

    0
  • M

    ja, bei glvertex is jedes argument eine koordinate, also ein x, ein y und ein z-wert. Wenn du also sowas schreibst:

    glVertex3f(1,1,1);

    Dann sagst du opengl, dass du an der Stelle (1,1,1) einen Punkt gesetzt haben möchtest. Das ganze ist nur ein Punkt des gesamten zu zeichnenden Körpers. Für ein Dreieck brauchst du 3 Punkte. zB:

    glVertex3f(1,1,1);
glVertex3f(1,0,1);
glVertex3f(0, 1, 1);

    Das ganze natürlich nciht vergessen, in glBegin(GL_TRIS) und glEnd() zu packen. Für einen Quader malst du dir am besten erstmal auf papier auf, welche koordinaten du dafür brauchst. Nimm am besten GL_QUADS bei glBegin, dann brauchst du weniger aufrufe.

    2.: Die Einheiten, mit denen du mals kannst du dir selber aussuchen. JE nachdem, was du als 1.0 interpretierst, so ist es auch. du kannst also zB ein Haus mit der Hölhe 1.0 malen (entspricht für dich dann meinetwegen 5m), dann sollte ein mensch aber nur die höhe 0.4 haben, also etwa 2 meter. Einen direkten Maßstab, dass 1.0 einer bestimmten Länge entspricht, gibt es nicht. Ich glaube eine allgemeine nutzung für normale spiele ist, 1.0f = 1m. Bei spaceshootern wird das nicht gehen, da sind die abstände ja noch größer 🙂

    Hoffe konnte helfen.
    Maxi

    0
  • P

    Erstmal vielen Dank.
    Es hat mir schon mal geholfen.
    Aber jetzt hätt ich noch so eine kleine Frage,
    also es müsste dann heissen, dass wenn ich das so machen würde :

    GL_BEGIN(GL_QUADS);
glVertex3f(Hier ist der Startpunkt die rechte Ecke also (x) -1.0f,Hier geht es von der oberen rechten Ecke nach unten (y),Hier geht es zur Betrachter Perspektive (z))
glEnd();

    Währe das so richtig ?
    UNd noch eine Frage, wenn ich mit x oben in der rechten Ecke angefangen hab, wird er ja nach links gezogen, das ist klar, aber wie ist das wenn ich mit y von der pberen rechten Ecke nach unten möchte ?
    Währe das dann - oder + ?
    Ich weiss nicht ob es nach oben hin + oder - ist.

    PS.: Aber du hast recht, hab mir mal grad alles Skizziert und es funktioniert wunderbar !!!!

    0
  • K

    http://graphics.cs.uni-sb.de/Courses/ws9900/cg-seminar/Ausarbeitung/Philipp.Walter/images/coords-simple.gif
    Ich glaube hier sieht man das ganz gut.
    Du trägst die Punkte nun einfach in das Koordinatensystem ein.

    0
  • M

    nochmal: jeder aufruf von glVertex3f erstellt nur EINEN Punkt. Keine Fläche, keine Linie, nix anderes. OpenGL macht dann aus einer MEnge vno Punkten (zB die Eckpunkte eines Rechtecks) die passende Fläche, welche bei glBegin angegeben wird. Mit einem einzigen Aufruf von glVertex3f kannst du also auch nur einen Punkt malen und keine Fläche.

    0
  • P

    Man ich mach gleich was kaputt vor Wut 😡 .
    Ich check das nicht.
    Kann mir mal vlt bitte einer eine richtige <Definitioen ausfühlrich schreiben ?
    Ich kriegs net hin.
    Alsooooo^^.
    Bei dem Quadrat, also ich stell mir das so vor, aber bitte bring mich einer von meinen Vorstellungen weg :

    glVertex3f(-1.0f, 1.0f, 0.0f);
    -Beginnt eine Linie von -1.0f nach rechts zu 1.0f zu zeichnen
    glVertex3f( 1.0f, 1.0f, 0.0f);
    -Fängt oben rechts an, wo die Linie vorher geendet hat, und setzt ab da eine Linie nach oben 1.0f
    glVertex3f( 1.0f,-1.0f, 0.0f);
    -Fängt an der ersten Zeichen Operation am 1.0f eine Linie runter zu zeichnen -1.0f
    glVertex3f(-1.0f,-1.0f, 0.0f);
    -Fängt an der ersten Zeichen Operation oben rechts an und zeichnet eine Lienie runter

    So Leute, ihr denkt euch jetzt bestimmt "Ist der Junge bekloppt oder was ???"
    UNd ja, ich bin grad voll bekloppt im Kopf.
    Ich dreh gleich am Rad, ich check grad ganix mehr.
    Bitte geb mir jetzt einer eine genaue Definition mit Code beispielen.
    Ich verteile Küsse für antworten, dankeeee.
    Wer auch mal Bock hat, mit mir bald mal ein kleines Spiel zu progge, (worauf eh keiner Bock hat), würde es mich freuen wenn ihr mich im icq Chat adden würdet, unter :
    388-760-975

    Ich danke HERZLICHST im Vorraus !

    0
  • T
     

    glVertex3f(0, 0, 0) //Setzt den Zeichenzeiger (von mir ausgedacht  :clown:) auf 0, 0, 0, (x, y, z)
glVertex3f(2, 0, 0) //Setzt den Zeichenzeiger auf 2, 0, 0, (x, y, z)
glVertex3f(0, 1, 0) //Setzt den Zeichenzeiger auf 0, 1, 0, (x, y, z)

    ... usw.

    Wie vorher schon gesagt wurde, jeder Aufruf von glVertex* setzt nur einen Punkt!
    Eine Linie setzt sich aus 2 Punkten Zusammen. (Anfang und Ende)
    Ein Quadrat aus 4 Punkten (Jede Ecke einer)
    usw.

    Edit:
    Für ein Quadrat gäbe es auch glRect* 🤡

    0
  • P

    Achso,
    mhm aber eine Frage hätt ich da immer noch^^.
    Also wenn ich ein Punkt gesetzt hab, und dann einen anderen Punkt setzte verbindet der sich dann mit dem davorigen Punkt automatisch ?Also, wenn ein Punkt1 gesetzt wird und dann Punkt 2 gesetzt wird, dass beide Punkte im GL_QUADS Befehl sofort automatisch verbunden werden ?
    Danke im Voraus.

    0
  • P

    Ach Leute shcon gut, habs grad rausbekommen, ich hab mir das viel komplizierter vorgestellt als es eigentlich ist.
    Aber trotzdem Danke !

    0
  • A

    Innerhalb von:

    glBegin(GL_QUADS)

glEnd();

    sucht OpenGL nach jeweils 4 Angaben von 3D Koordinaten, gegeben mit glVertex3f(...)
    und interpretiert diese 4 Angaben als die 4 Ecken des 4 Ecks.

    Findet OpenGL z.B nur 2 3DKoordinaten mit glVertex3f(...) wird nichts gezeichnet
    (auch keine Linie).
    Weil um ein 4 Eck eindeutig zu bestimmen nunmal 4 Eckpunkite nötig sind.

    Schreibst du allerdings die Angaben von 8 3DKoordinaten mit glVertex3f(...)
    dazwischen, so wirst du 2 Vierecke erhalten. Mit 12 Angaben 3 Vierecke usw.

    Wenn du eine Linie haben willst mußt du glBegin(GL_LINES) verwenden.
    Dann sucht OpenGL innerhalb von

    glBegin(GL_Lines)

glEnd();

    nach 2 Angaben von 3DKoordinaten (wieder gegeben mit glVertex3f(...) ).
    Bei nur einer Angabe wird nichts gezeichnet. Bei 2 Angaben erhälst du eine Linie. (Weil 2 Angaben reichen um eine Linie eindeutig zu bestimmen)

    Bei 4 Angaben wirst du 2 Linien erhalten. Bei 5 Angaben auch nur 2 Linien.
    Bei 6 Angaben 3 Linien usw...

    0
  • ?

    Ich hätte da auch mal eine Frage. Ich habe bis jetzt mit DX experementiert und überlege mir es, auf OGL umzusteigen.

    glBegin(GL_QUADS) 
glVertex3f(0, 0, 0);
...
glEnd();

    Entspricht das in etwa einem Dynamischen VertexBuffer in DX?
    Wenn ja: Wie macht man statische Buffer?

    0
  • P

    http://nehe.gamedev.net/

    Da solltest du was finden.

    0
  • ?

    pivke schrieb:

    http://nehe.gamedev.net/

    Da solltest du was finden.

    sieht vielversprechend aus.

    thx

    0
  • P

    Ich denk mal du bist mit Open GL frisch am Werk, wie ich.
    Also ich musste lange suchen um richtig gute Seiten mit Tutorials/-Erklärungen zu bekommen.
    Hier meine Top Liste :

    www.joachimrohde.com
    www.videotutorialsrock.com
    http://nehe.gamedev.net

    0
  • P

    Und im Übrigem hab ich noch meinen 3D Würfel fertig geschrieben.
    (Es ist mein erstes gelungenes 3D Objekt, worüber ich überaus stolz bin ;-))
    Also hier der Code meines 3D Objektes (3D-Würfel) :

    int DrawGLScene(GLvoid)									// Here's Where We Do All The Drawing
{
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 
	glLoadIdentity();									// Reset The Current Modelview Matrix
	glTranslatef(-2.5f,0.0f,-6.0f);						

	glTranslatef(2.5f,0.0f,0.0f);						
 glRotatef(rquad,10.0f,10.0f,0.0f);
    glBegin(GL_QUADS);									
		//* Grün Vordere Seite
        glColor3f(0.0f,10.0f,0.0f);
        glVertex3f(-1.0f, 1.0f, 0.0f);					
		glVertex3f( 1.0f, 1.0f, 0.0f);					
		glVertex3f( 1.0f,-1.0f, 0.0f);					
		glVertex3f(-1.0f,-1.0f, 0.0f);					
        //* Rot Rechte Seite
        glColor3f(10.0f,0.0f,0.0f);
        glVertex3f(1.0f,1.0f,0.0f);
        glVertex3f(1.0f,1.0f,-1.8f);
        glVertex3f(1.0f,-1.0f,-1.8f);
        glVertex3f(1.0f,-1.0f,0.0f);
        //* Blau Linke Seite
        glColor3f(0.0f,0.0f,10.0f);
        glVertex3f(-1.0f,1.0f,0.0f);
        glVertex3f(-1.0f,1.0f,-1.8f);
        glVertex3f(-1.0f,-1.0f,-1.8f);
        glVertex3f(-1.0f,-1.0f,0.0f);
        // Gelb Hintere Seite
        glColor3f(10.0f,100.0f,0.0f);
        glVertex3f(-1.0,1.0f,-1.8f);
        glVertex3f(1.0f,1.0f,-1.8f);
        glVertex3f(1.0f,-1.0f,-1.8f);
        glVertex3f(-1.0f,-1.0f,-1.8f);
        // Hellblau Obere Seite
        glColor3f(0.0f,10.0f,10.0f);
        glVertex3f(-1.0f,1.0f,0.0f);
        glVertex3f(-1.0f,1.0f,-1.8f);
        glVertex3f(1.0f,1.0f,-1.8f);
        glVertex3f(1.0f,1.0f,0.0f);
       // Weiss Untere Seite
       glColor3f(10.0f,10.0f,10.0f);
       glVertex3f(-1.0f,-1.0f,0.0f);
       glVertex3f(-1.0f,-1.0f,-1.8f),
       glVertex3f(1.0f,-1.0f,-1.8f);
       glVertex3f(1.0f,-1.0f,0.0f);
    glEnd();											

      rquad-=0.55f; 
    return TRUE;										//
}

    Und hier noch mal für die, die den kompletten Code haben möchten oder nicht die Gelegenheit dazu haben, sich den Code umzuändern oder einzufügen bzw. kompilieren, hab ich die Datei (Executable) samt den Source Code hochgeladen.
    Nämlich hier :
    (Der Source Code liegt im Dev-C++ Format vor)

    http://www.megaupload.com/de/?d=JPHKC0CK

    0
  • M

    Ich frag mich ganz ernsthaft, warum du glColor3f mit Werten >1.0 bestückst?
    http://www.glprogramming.com/blue/ch05.html#id5458953

    gruß
    Martin

    0
  • P

    Hey,
    ja das liegt wohl daran das ich noh ein Noob in Sachen 3D Programmierung und
    TEXTURIERUNG bin.
    Aber danke für deine Bemerkung.

    0
  • M

    Mit Texturierung hat das noch nichts zu tun, das ist wieder ein anderes Thema.

    Ich hab es auch nur erwähnt, weil ich selbst unvorhergesehenes Verhalten erlebt hab. Bei den glColorxf hast du immer floats zwischen 0.0f und 1.0f. 0 ist 0 und 1.0f würde als Byte auf 255 umgerechnet. Wenn du nur Werte zwischen 1.0f und 0.0f eingibst, kommt auch nur das raus, was du wirklich möchtest. Ist sauberer so.

    gruß
    Martin

    0
  • P

    Ja ok danke ich werds mal ausprobieren.

    0
  • P

    SilentRob schrieb:

    Ich hätte da auch mal eine Frage. Ich habe bis jetzt mit DX experementiert und überlege mir es, auf OGL umzusteigen.

    glBegin(GL_QUADS) 
glVertex3f(0, 0, 0);
...
glEnd();

    Entspricht das in etwa einem Dynamischen VertexBuffer in DX?
    Wenn ja: Wie macht man statische Buffer?

    Das ist gar kein Puffer. Du tust ja die Daten einzeln an OGL übergeben.
    Wenn du Puffer willst, schau dir Vertexarrays und/oder VBOs an. Das entspricht dann eher dem Prinzip, was du aus DX kennst.

    0
Anmelden zum Antworten