| Autor |
Beitrag |
Shadow
Ehemaliges Mitglied
Erhaltene Danke: 1
|
Verfasst: Do 27.06.02 21:40
Hallo Leutz
Nett das ihr reinschaut. Habt ihr kein Plan von OpenGL, dann seid ihr hier richtig. Dies ist mein erstes Tutorial und dann gleich bei so viel Publikum. Ich hab kein Bock euch die Geschichte von OpenGL rein zu knallen deswegen geht es fast gleich richtig zur Sache.
SORRY WENN ICH N PAR RESCHTSCGRIBFEHLA HAB, ich bin Ausländer müsst ihr
verstehen.
Das einzige was ihr wissen müsst ist, dass OpenGL genau wie DirectX eine Schnittstelle ist. Dort werden Informationen gespeichert. Sie wurde von Silicon Graphics (c) entwickelt und man kann mit fast allen Programmiersprachen drauf zugreifen.
Ich weiß nicht genau woher ihr die neusten DLLs herkriegt und die Delphi Dateien (gl.Pas glu.Pas OpenGL.pas) einfach unter www.google.de nach "OpenGL.pas Download" suchen. Wen jemand weiß woher man die kriegt bitte posten.
Als erstes worauf man sich umstellen(einstellen) muss wenn man mit OpenGL programmiert und was wichtig ist:
- Alle Befehle die über OpenGl laufen beginnen mit gl... z.B: glBegin, glColor3f, glViewPort, gluPerspective... Zu den begriffen später.
- Man muss(kann, aber ist besser) andere Grund-Variablen nehmen: z.B: Ist Real in OpenGL = glFloat (eine GleikommaZahl) Ich benutze fast nur diese Änderung. String usw. können beibehalten werden.
- Man muss(leider) erst mal OpenGL initaliesieren das sieht kompliziert aus aber wenn man es erst mal 3-4 mal geschrieben hat, hat man es im Kopf und versteht es auch. Außerdem ist es viel einfacher als die Initaliesierung von DirectX
- Viele Befehle enden zum Schluss mit einem Buchstaben, der angibt was für Variablen als Parameter übergeben werden. z.B: glTranslatef(0.1,3.002,-0.23) f steht für Float=Real also eine Kommazahl. Ich benutze eigentlich fast immer f . Aber es gibt auch diesen:
  Delphi-Quelltext
1:
2:
3:
4:
| const
w:Array[0..2]of Glfloat=(0.1,1,0);
begin
glLightfv(GL_LIGHT0,GL_AMBIENTE,@w] | das v bedeutet, dass ein Pointer als letzter Parameter übergeben wird mit Floats(f) als Inhalt. Dieser befehl ändert die Licht Farbe aber das wird noch erklärt.
Wenn es zu kompliziert wird, dann beschimpft mich ruhig oda wenn ich *mist*e erkläre, wisst ihr mein Cousin sagt ich kann voll nicht erklären, aber dass ist eine andere Storry.
So jetzt geht es los.INITALIZIERUNG. Wir öffnen ein neues Projekt und binden die OpenGL unit ein:
Delphi-Quelltext
Wir brauchen zwei Variablen im Bereich wo auch die Form definiert ist:
Delphi-Quelltext
1:
2:
3:
4:
| var
Form1:TForm1;
DC:HDC;
RC:HGLRC; |
DC ist der Bereich wo wir zeichnen wollen z,B: in ein Panel oda in die Form.
RC ist zu Regelmäßigen Rendern.
So jetzt kommt ein koplizierterer Teil aber lasst euch nicht die Lust nehmen Kinder, danach wirds einfach: Tipp: Kopiert den Text nicht einfach in euer Programm sondern Schreibt ihn ab, das hilft zum lernen. Im onCreate-Ereignis müssen wir OpenGL einstellen:
Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
| procedure TForm1.FormCreate(Sender: TObject);
var
pfd:TPixelFormatDescriptor;
p:Integer;
begin
fillchar(pfd,sizeof(pfd),0);
DC:=getDC(Form1.Handle);
pfd.cDepthBits:=16;
pfd.cColorBits:=16;
pfd.dwFlags:=PFD_DRAW_TO_WINDOW or PFD_SUPPORT_OPENGL or PFD_DOUBLEBUFFER;
p:=choosePixelFormat(DC,@pfd);
setPixelFormat(DC,p,@pfd);
RC:=wglCreateContext(DC);
wglMakeCurrent(DC,RC);
glClear(0,0.5,1,0);
end; |
Sieht heftig aus ist es aber nicht:
- Pfd erhält die Infos zur Einstellung von OpenGL
- p wir zum ermitteln der Farbtiefe oder so benötigt.
- fillchar.. stellt pfd auf Null, das spart viel Text anstatt alles erst mal auf Null zu setzen
- DC wird auf die Form eingestellt, das heißt, wir malen in die Form rein
- pfd Einstellungen: Tiefenbuffer auf 16 Farbtiefe auf 16
SO jetzt eine der Wichtigsten Einstellungen:
- dwFlags sagt wie ins Fenster gemalt werden soll.
- PFD_DRAW_TO_WINDOW = mal in ein Fenster
- PFD_SUPPORT_OPENGL = erlaube dort OpenGL
- PFD_DOUBLEBUFFER = Zwei Buffer= kein Flimmern bei Animationen
INFO: PFD gehört nicht zu openGL sondern zu Windows!
- choosePixelFormat und setPixelFormat stellt das Format der Pixel ein
- Danach wir das Rendering Contst zum Render erstellt und DC zugefügt.
glCLearColor stellt ein mit welcher Farbe gerendert wird
glClearColor(r,g,b,a:Glfloat) r=rot g=Grün b=Lila Scherz b=Blau und a=Alpha(Unwichtig für uns)
Dieser Code allein reicht aber nicht ein bisschen Fehlt noch: OpenGL ist initaliziert muss aber nicht regelmäßig gerendert werden. Ich benutze eigentlich die OnIdle Funktion aber macht ihr es Erst mal mit einem Timer (Interval=1  . Das OnTimer Event sieht so aus
Delphi-Quelltext
1:
2:
3:
4:
5:
| procedure TForm1.Timer1Timer(Sender: TObject);
begin
glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);
SwapBuffers(DC);
end; |
Der Tiefen- und Farbbuffer wird gecleart und die Buffer werden vertauscht, wir haben doch PFD_DOUBLEBUFFER. Jetzt müssen wir nur noch den Speicher beim beenden des Programms frei machen, dass sieht so aus:
Delphi-Quelltext
1:
2:
3:
4:
5:
6:
| procedure TForm1.FormDestroy(Sender: TObject);
begin
wglMakeCurrent(DC,0);
wglDeleteContext(RC);
releaseDC(0,DC);
end; |
Startet das Programm und ihr müsstet eine mit schön Blau gefüllte Form sehen, wenn nicht, dann höre ich sofort auf mit dem Tut, weil ich dann wirklich nicht erklären kann
Also das wars erst mal ich beeile mich mit dem nächsten Teil. Bitte sagt wie ich war und macht mich richtig fertig wenn ich *mist*e erkläre.
PS: Ich habe in Informatik auf dem Zeugnis ne 1. GEIL ODA?
Zuletzt bearbeitet von Shadow am Sa 29.06.02 11:40, insgesamt 3-mal bearbeitet
|
|
Alibi
 
Beiträge: 458
Win2K SP3
Delphi 6 Ent
|
Verfasst: Do 27.06.02 22:32
Schick Blau.
Einen Fehler hattest du drin:
Statt
Delphi-Quelltext
1:
2:
3:
4:
| procedure TForm1.FormCreate(Sender: TObject);
[...]
glClear(0,0.5,1,0);
end; |
Das:
Delphi-Quelltext
1:
2:
3:
4:
| procedure TForm1.FormCreate(Sender: TObject);
[...]
glClearColor(0,0.5,1,0);
end; |
Moderiert von  raziel: Code- durch Delphi-Tags ersetzt.
|
|
Shadow
Ehemaliges Mitglied
Erhaltene Danke: 1
|
Verfasst: Fr 28.06.02 16:15
Titel: Sorry
jo stimmt. Danke. Ich werde mehr darauf achten, das ich keine Fehler mache. Arbeite jetzt gleich an Teil 2. Wenn ihr Glück habt,dann schaffe ich es noch Heute.
|
|
Shadow
Ehemaliges Mitglied
Erhaltene Danke: 1
|
Verfasst: Sa 29.06.02 00:01
Titel: OnIdle und Framerate
Hi hier ist Teil 2 des OpenGL Tutorials:
Ich werde die Initalisierungs Infos und Prozeduren und Befehle auslassen, da sie oben erklärt sind.
Als erstes möchte ich erklären, wie man die OnIdle Procedure benutz, da diese viel Besser als ein Timer ist, sie ist schneller.
Außerdem zeige ich euch, wie man die FPS-Rate berechnet(FPS = Frames Pro Second).
Zur OnIdle-Funktion: Nicht sehr kompliziert.
Erstellt eine Procedure zur Form namens OnIdle, der Name und die Parameter müssen übereinstimmen, d.h. ihr dürft diese nicht ändern.
Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
| ...
private
procedure OnIdle(Sender:TObject;var Done:Boolean);
public
end;
... |
Nun schreibt ihr diese Procedure auch in euren Quelltext, die muss so aussehen:
Delphi-Quelltext
1:
2:
3:
4:
5:
6:
| procedure TForm1.onidle(Sender:TObject;var Done:Boolean);
begin
Done:=FALSE;
glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);
SwapBuffers(DC);
end; |
Ihr müsst Done immer auf False setzen, denn wenn Done=True ist wird diese Procedure nicht immer wieder ausgeführt.
So nun müsst ihr nur noch die Application.OnIdle Procedure auf eure Setzen.
Bei Form1.OnCreate:
Delphi-Quelltext
1:
2:
3:
4:
| procedure TForm1.FormCreate(Sender: TObject);
begin
Application.OnIdle:=Form1.OnIdle;
end; |
So jetzt braucht ihr kein Timer mehr der nur jede millisekunde rendert sondern habt eine sehr viel schnellere Procedure.
Damit ihr nicht denkt, dass ich euch verarsche, zeige ich euch wie ihr die FPS berechnen könnt:
Delphi-Quelltext
1:
2:
3:
| var
Form1:TForm1;
Framerate:Integer; |
Framerate ist ein Integer, wie ihr seht . Dieser muss immer hochgezählt werden, wenn die Szene gerendert(gemalt)wird, wer hat es erfasst? Klar in der OnIdle-Prozedure oder in dem OnTimer-Ereignis(wenn ihr noch Timer benutzen wollt)schreibt ihr hinzu
Delphi-Quelltext
1:
2:
3:
4:
5:
6:
| procedure Tform1.onidle(Sender:TObject;var Done:Boolean);
begin
...
inc(Framerate);
...
end; |
Da es FramesProSecond heißt, erstellt ihr einen Timer mit Interval=1000(1 Sekunde)
der überprüft Framerate auf seinen Inhalt gibt diesen in dem Fenster aus und stellt ihn wieder auf 0.
Delphi-Quelltext
1:
2:
3:
4:
5:
| procedure TForm1.Timer1Timer(Sender: TObject);
begin
form1.Caption:=OpenGL-Demo by Shadow www.2strong.da.ru FPS: '+inttostr(framerate);
framerate:=0;
end; |
Startet das Programm und oben im Fenster steht die Framerate.
Sehr hoch, weil wir noch nichts zeichnen, aber das kommt bald, sehr bald meine Niggas.
Testet es mit einem Timer, dieser ist sehr viel langsamer(bei mir zumindest).
Ich weiß ihr kommt euch verarscht vor, wenn ihr nur eine Form habt, in der noch nichts ist. Es juckt euch in den Fingern oder? Aber das malen erfordert ein paar Befhele die ich euch nicht einfach reinknallen will, sondern euch alle erklären will, damit ihr auch genau wisst, wie es geht und schlecht über mich redet „ja der Shadow, der erklärt voll schlecht“
Also das nächste Tut wird darüber handlen, wie man malt.
Moderiert von raziel: Code- durch Delphi-Tags ersetzt.
|
|
Shadow
Ehemaliges Mitglied
Erhaltene Danke: 1
|
Verfasst: Sa 29.06.02 11:41
OpenGl Tutorial Teil 3
Hey Kinder,
jetzt geht es weiter mit dem wichtigsten Part, das malen und die wichtigsten Funktionen zum malen.
Wenn ihr die Initalisierung und die Framrate-Berechnung schon beherscht, dann zeig ich euch jetzt wie es geht.
Info: Die Infos von den beiden anderen Kapiteln werden hier nicht aufgeführt.
Bevor wir malen können müssen wir die Szene richtig positionieren und einstellen, da ist die OnRezose-Prozedure perfekt, denn jedes mal wenn die Fenster-Größe geändert wird,
muss sich die Szene auch aufs Fenster anpassen. Da wir vorher nur ne schwarze Szene hatten war das nicht nötig.
Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
| procedure TForm1.FormResize(Sender: TObject);
begin
glViewPort(0,0,clientwidth,clientheight);
glMatrixMode(GL_PROJECTION);
glLoadIdentity;
gluPerspective(45,clientwidth/clientheight,0.1,100);
glMatrixMode(GL_MODELVIEW);
end; |
Vergisst nicht, den Code nicht zu kopieren, sondern schreibt ihn ab.
Wie ihr seht, sind das alles OpenGl befehle, da sie mit gl... anfangen.
glViewPort(x,y,endx,endy) stellt die Breite und so für OpenGL ein
glMatrixMode stellt die Matrix Einstellungen ein(welche Informationen in den Buffer gespeichert werden sollen.) glLoadIdentity stellt die Matrixposition auf 0(X=0, y=0,z=0);
Wichtig: gluPerspective...
Parameter1:Ansicht auf die Szene.
Parameter2:Breite durch Höhe der Szene hier angeben
Parameter3+4:Nur die Objecte, die sich zwischen diesen Punkten befinden werden auch angezeigt.
Ehrlich gesagt, dies ist die einzige Prozedure, die ich am wenigsten verstehe, aber ohne sie funktioniert nix.
So jetzt können wir zeichnen: Schreibt in eure OnIdle-Prozedure folgenes:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
| procedure TForm1.OnIdle(Sender:TObject;var Done:Boolean);
begin
Done:=FALSE;
inc(framerate); glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT); glTranslatef(0,0,-5);
glRotatef(4,1,0,0);
glRotatef(3,0,1,0);
glRotatef(2,0,0,1);
glBegin(GL_QUADS);
glVertex3f(-1,-1, 1);
glVertex3f( 1,-1, 1);
glVertex3f( 1, 1, 1);
glVertex3f(-1, 1, 1);
glVertex3f(-1,-1,-1);
glVertex3f(-1, 1,-1);
glVertex3f( 1, 1,-1);
glVertex3f( 1,-1,-1);
glVertex3f(-1, 1,-1);
glVertex3f(-1, 1, 1);
glVertex3f( 1, 1, 1);
glVertex3f( 1, 1,-1);
glVertex3f(-1,-1,-1);
glVertex3f( 1,-1,-1);
glVertex3f( 1,-1, 1);
glVertex3f(-1,-1, 1);
glVertex3f( 1,-1,-1);
glVertex3f( 1, 1,-1);
glVertex3f( 1, 1, 1);
glVertex3f( 1,-1, 1);
glVertex3f(-1,-1,-1);
glVertex3f(-1,-1, 1);
glVertex3f(-1, 1, 1);
glVertex3f(-1, 1,-1);
glEnd;
SwapBuffers(DC);
end; |
So, die ersten drei Zeilen, kennt ihr schon,
glTranslatef(x,y,z:Glfloat) verschiebt die Matrix, alle Objekte die nach glTranlatef kommen sind um seinen Wert(glFloat wegen dem f )verschoben,
Was die x-,y-,z-Achsen sind wißt ihr hoffentlich:
x:Von Links nach Rechts
y:Von Unten nach Oben
z:Von Vorne nach Hinten(Rein und Raus )
glRotatef(angle,x,y,z:Glfloat); rotiert alles mit dem Wert "Angle" um die 3 Achsen:
Wenn x=1 ist, wird alles um die X-Achse gedreht
Wenn y=1 ist, wird alles um die Y-Achse gedreht
Wenn z=1 ist, wird alles um die Z-Achse gedreht
Jetzt kommt das malen:
glBegin fängt das malen an, der Parameter sagt, was wir malen wollen.
Es gibt folgende(es gibt noch mehr aber kein Bock die alle aufzuzählen)
GL_LINES:Eine Linie
GL_QUADS:Viereck-Fläche
GL_POLYGON:Mehrfacheck
GL_TRIANGLE:Dreieck
mit glEnd wird signaliesiert, dass das Malen zu ende ist.
alles was dazwischen steht wir gemalt.
Nun zu glVertex3f(x,y,z:Glfloat);
3f,bedeutet, dass wir Dreidimensional malen wollen mit dem Parametern als glFloats.
es gibt auch 2f, das wäre 2D
Die Werte geben zusammen einen Punkt(Vertex) auf dem Koorinaten System an, dieser wird mit dem nächsten Vertex verbunden und dieser mit dem Nächsten usw. bis die gewünschte Form ferteig ist(in unserem GL_QUADS) dann fängt das nächste Objekt an.
Wir malen also einen Würfel, startet das Programm aber ihr seht nur einen weißen Grundriss des Würfels.
Hier könnten wir Licht benutzen um ihn deutlicher zu machen oder die Farbe der Fläche ändern.
Bei Farben ist es genau so wie bei glTranlatef, alle Objekte, die danach folgen haben diese Farbe.
glColor3f(r,g,b:Glfloat)
r,g und b haben höchstens den Wert 1
schreibt nach jedem vierten Punkt
glColor3f(0,0.5,1) (Beispiel) und ändert sie Werte wie ihr wollt.
Startet das Programm und ihr habt einen schönen bunten Würfel, aber die Flächen, die eigentlich hinter einer anderen Fläche sind werden trotzdem angezeigt???
Was machen wir meine Niggas?
dafür gibt es glEnable...
damit wird eine Eigenschaft aktiviert(z.B Nebel, Licht, AlphaBlending uws.)
schreibt bei eurer OnCreate-Prozedure unten hinzu
Delphi-Quelltext
1:
| glEnable(GL_DEPTH_TEST); |
glDisable macht genau das gengenteil brauchen wir aber nicht.Start
wieder und "geilo" (kennt ihr Shin Chan )
Ich glaube das wars mit dem Tutorial, denn es gibt nur noch kleinigkeinten wie z.B
Licht
Texturen(sehr kompliziert)
Nebel
Matrix-Einstellungen
AlphaBlending(Durchsichtige Flächen)
Wenn ihr wünsche habt, einfach melden und ich erkläre diese Thema.
Hoffe ihr hattet Spaß Kids.
Shadow
Moderiert von raziel: Code- durch Delphi-Tags ersetzt.
|
|
Arakis
Beiträge: 344
|
Verfasst: Sa 29.06.02 16:33
Jo, hätt ich.
Warum sind die 3D-Objekte so laaaaahm, jetzt mal nicht auf dein Beispiel bezogen. Ich habe mir viele Tutorials im Bereich DirectX und OpenGL angeschaut, mit der Feststellung, dass bei mehr als einam Objekt das ganze so stockend wird, dass das Ganze gar keinen Spaß mehr macht. Was ist denn schneller OpenGL oder DirectX? Ich habe keine 3D-Grafikkarte, aber Spiele wie Half-Life oder Counter-Strike schaffen es ja auch, ohne dessen sehr gute Ergebnisse zu erziehlen. Würd mich über eine gute Antwort freuen.
Bis dann
 _________________ Mit dem Computer löst man Probleme, die man ohne ihn nicht hätte.
Entwickler von SpaceTrek: The New Empire - Siehe Hompage!
|
|
Shadow
Ehemaliges Mitglied
Erhaltene Danke: 1
|
Verfasst: Sa 29.06.02 16:58
Titel: Mmmhhh
Ich weiß auch nicht genau, denke dass es an deiner Farbtiefe oder Auflösung liegt, wenn du die Auflösung auf 800x600 stellst und die Farbtiefe auf 16 dann müsste es gehen, also bei mit kann ich 15.000 Vertexe setzen und erhalte mit meiner 4MB Intel Grafik karte noch 25FPS.
Ob DirectX schneller ist als OpenGL kann ich dir nicht sagen, tut mir leid
Hoffe konnte dir helfen
Shadow
|
|
Arakis
Beiträge: 344
|
Verfasst: Sa 29.06.02 17:11
Gilt das auch, wenn ich zwar eine Auflösung von 1024x768 habe, aber das Programmfenster auf 800x600 habe? Es programmiert sich nämlich sehr unbequem in 800x600
Liegt die Lahmheit teilweise an der Programmiersprache Delphi? Oder was mir aufgefallen ist: In einem geschlossenen 3D-Raum ist die FPS-Rate höher, als in einem Raum, der ein "Loch" hat. Das ist jedenfalls bei Half-Life-Maps so.
Bis dann
_________________ Mit dem Computer löst man Probleme, die man ohne ihn nicht hätte.
Entwickler von SpaceTrek: The New Empire - Siehe Hompage!
|
|
Shadow
Ehemaliges Mitglied
Erhaltene Danke: 1
|
Verfasst: So 30.06.02 15:02
Titel: Ein Bisschen...
Ja wenn du die Auflösung 1024x768 hast und das Fenster in 800x600 dann ist es langsamer, zwar nicht viel aber es ist so. Das mit dem Raum weiß ich nicht, aber an Delphi liegt es nicht, da die Programmierung unter C++ und Delphi mit OpenGL dieselbe ist, es wird auf die selben DLL's zugegriffen, und das hat nichs mit der Programmiersprache zu tun. Obwohl mir jetzt etwas einfällt:
Bei mir ist es so wenn ich ein OpenGL Projekt mache und dann ausführe ist es langsam, wenn ich dann aber die EXE normal öffne läuft es gut, das liegt an delphi, der Debugger prüft die Anwendung auf Fehler, wenn sie läuft, das kannst du unter(Delphi 5) "Tools"-"Debugger-Optionen"-"Intergrierte Fehlersuche" abstellen.
Shadow
|
|
Mr_T
Beiträge: 73
Win XP, Fedora Core RC 1
|
Verfasst: So 07.07.02 22:25
Ich kann mir denken, warum in diesen Beispielen das alles noch recht langsam ist, oder auch flackern könnte ... ich habe selber mal mit OpenGl gecodet (aber nur kurz ... ist auch etwas her) , daher kann ich sagen, das die sogenannten Displaylisten noich nciht vorkamen (fragt mich nciht, wie das geht - ich weiß es nicht mehr genau) ..... diese Listen haben folgendes zu bedeuten: in diesen Beispielen, wird bei jedem neuzeichnen alles neu berechnet - besonders bei großen Zenarien sehr rechenauffwendig ... bei Displaylisten werden die Objekte schon komplett ferig in Listen gespeichert, die dann nur noch mit glcalllist(nummer der liste) ausgegeben werden - bringt ne menge Speed.......
|
|
tommie-lie
Beiträge: 4373
Ubuntu 7.10 "Gutsy Gibbon"
|
Verfasst: So 21.07.02 16:14
Ich will ja keinen anschwärzen, aber hier hat keiner so richtig Ahnung von 3D.
Also, auch wenn das Topic schon etwas länger nicht mehr läuft, will ich für's Archiv mal einige machen richtigstellen und Wissensdurst stillen:
@Arakas
Prinzipiell ist OpenGL und DX gleich schnell. Da beide nur die reine Software-Schnittstelle zur Vefügung stellen, kommt es ausschließlich auf den Treiber an, welche Befehle er schneller verarbeiten kann. DirectX hat jedoch gerade in den letzten Versionen Zusatzfunktionen erschaffen (T&L, programmable Vertax Shader, Pixel Shader) die so nicht exakt in OpenGL vorkommen. Hat eine Karte die genannten Eigenschaften (GF4 z.B.) so kann man einen deutlichen Geschwindigkeitszuwachs im Vergleich einer älteren Karte verzeichnen. Will man die gleichen Effekte in einer alten DX-Version (oder OGL) muss man sie emulieren. Das dauert länger.
Im Endeffekt spielt es also keine Rolle, ob man in OGL oder DX programmiert, denn die Hardware-Befehle sind im Großen und Ganzen gleich. Die FireGL-Karten sind zum Beispiel auf OGL optimiert, und bieten alles, was das OGL-Herz begehrt. Wies bei den Karten mit DX aussiieht, weiß ich nicht.
Die eigentliche Umwandlung der Befehle in "Maschinensprache" machen die Treiber.
Natürlich wird man jetzt sagen, OGL-Spiele laufen aber auf meiner XXX-Karte langsamer.
Das liegt an der Programmierung. Man kann komplex programmieren, wodurch schöne Effekte auch auf älteren Karten möglich sind und viele "Schnörkel" einsetzen, aber das geht dann auf Kosten der Performance. Einige Funktionen sind sogar nur über "Umwege" zu erreichen.
Bsp:
Man kann rechnen
5-3-2=0
oder
5-3=x
x-2=0
Mehr aufwand beim unteren
Warum es mit mehreren Objekten immer langsamer wird, hat eine einfache Erklärung:
Je mehr Objekte, desto mehr Speicher braucht der Prozessor (GPU, oder CPU bei zu alten GraKas) um die Funktionen bereitzustellen.
Würde man den Speicher nach jedem Objekt wieder löschen um den vollen speicher dem aktuellen Objekt zuzuweisen, wäre das viel zu umständlich und vor allem zu langsam.
@Arakis Teil2
Wenn man das Ding nur auf 800 Punkten laufen läßt, aber der Desktop aus 1024 Punkten besteht, muss doch die Grafikkarte trotzdem alle Punkte darstellen. Ausserdem braucht der desktop selbst (umliegende Icons und Fenster) ja auch noch Speicher, nicht nur das 800 Punkte große Fenster in der Mitte. Also wieder ein Mehraufwand, im Vergleich zu echten 800Punkten.
Das mit dem Raum liegt daran, daß, wenn man nur den raum sieht, nur der Raum berechnet wird. Also hauptsächlich die Wände und Einrichtungsgegenstände. Man kann also nur relativ begrnzt weit sehen.
Ist man jedoch "unter freiem Himmel" werden alle Objekte gerendert und zusätzlich noch der Himmel gezeichnet. der muss sich ja mitbewegen, wenn man sich selbst bewegt (bzw. aus der First-Person-Sicht stehenbleiben). Das braucht extra-rechenleistung.
Das tritt jedoch hauptsächlich bei Kyro-Karten auf, da diese Tile-Based sind (siehe www.tilebase.de www.mitrax.de) und somit einen Unterschied zwischen "mit Horizont" und "Ohne Horizint" erkennen können. Bei gängigen anderen Karten ist das anders. Die rechnen blind und DUMM alles mit, ob man es sieht, oder nciht. Einige Spiele sind so programmiert, daß sie intern die Kyro-Technik intern verwenden, sodaß es keinen Unterschied macht, ob man die Kyro benutzt, oder nicht. Wiederum einige "normale" Treiber und Treiber-Hacks benutzen die Kyro-Technik ebenfalls.
Ziel der Kyro-Technik ist es, die Performance zu erhöhen (was meiner Anischt nach, reibungslos klappt, ich hab nänlich slber eine) , siehe mitrax und tilebase.
Mr_T kann ich mich nur anschließen, diese Technik wird aktuell jede Menga benutzt, wodurch die hohen Speicheranforderungen entstehen. (bis zu 128MB auf einer GraKa, das haben andere nciht im ganzen Computer). Aber schneller ist es allemal. Deswegen benutzen es Spielehersteller es ja.
Ach ja, Shadow:
Mit 4MB kann man OHNE Texturen ohne Probs 1024*786*32 einstellen. Wenn man die Zahlen mal durch den Taschenrechner schickt, kommen nämlich nur 3,1MB raus. Das reine Berechnen braucht ja kaum Speicher. Hat man aber Texturen, oder Mr_T's ObjectLists, braucht man mehr Speicher, oder eine niedrigere Auflösung. In deinem Tutorial war soweit ich das gesehen hab keine Rede von Texturen, sodaß man die Auflösung ohne weiteres an die Grenzen des Speichers anpassen kann.
Ansonsten war das Tutorial gut.
Alpha-Blending ist übrigens eine in Windows2000 eingeführte Technik, um Objekte Transparent erscheinen zu lassen. Natürlich gab es das schon vorher, aber das war es im Treiber drin. Mit Win2000 hat nan die Möglichkeit, einzelne Fenster transparent darzustellen. (Oder war das erst mit WinXP?) Egal, mit dem aktuellen Windows ist's im OS, vorher war's in DX. Wahrscheinlich benutzt aber Windows die APIs von DX um das darzustellen, DX ist ja schon vorinstalliert. _________________ Your computer is designed to become slower and more unreliable over time, so you have to upgrade. But if you'd like some false hope, I can tell you how to defragment your disk. - Dilbert
|
|
Arakis
Beiträge: 344
|
Verfasst: So 21.07.02 18:57
Donnerwetter, das ist ja ne ganze Menge.
Alles sehr interessante Informationen, nach denen ich schon lange suchte 
Zum Alpha-Blending: Das gibt es tatsächlich schon unter Windows 2000
Und zur Grafikkarte: Ich hab eine Standart 2D-Latpop-Grafikkarte. Jedenfalls läuft da Half-Life im Softwarerender von 800x600 100% fließend. (Mit 366 Mhz). Muss ja eine teufisch verknotete 3D-Engine sein; (Dein Zitat: "Einige Funktionen sind sogar nur über "Umwege" zu erreichen")
Bis dann
_________________ Mit dem Computer löst man Probleme, die man ohne ihn nicht hätte.
Entwickler von SpaceTrek: The New Empire - Siehe Hompage!
|
|
tommie-lie
Beiträge: 4373
Ubuntu 7.10 "Gutsy Gibbon"
|
Verfasst: Mo 22.07.02 15:53
| Arakis hat folgendes geschrieben: |
Und zur Grafikkarte: Ich hab eine Standart 2D-Latpop-Grafikkarte. Jedenfalls läuft da Half-Life im Softwarerender von 800x600 100% fließend. (Mit 366 Mhz). Muss ja eine teufisch verknotete 3D-Engine sein; (Dein Zitat: "Einige Funktionen sind sogar nur über "Umwege" zu erreichen")
|
Ich hab ja nicht gesagt, daß es bei allen Spielen und im Speziellen HL so ist. Nur das eben manches nicht so wirklich automatish geht. _________________ Your computer is designed to become slower and more unreliable over time, so you have to upgrade. But if you'd like some false hope, I can tell you how to defragment your disk. - Dilbert
|
|
Pierre
Beiträge: 138
Win 98se und XP prof
D5Pers und D7Prof
|
Verfasst: Di 05.11.02 13:19
Hallo,
erst einmal vielen Dank für dies Tutorial!
Ich möchte noch zwei Anmerkungen machen:
1. Der Unterschied ziwschen OpenGL und DirectX ist, dass DirectX nur unter WINDOWS arbeitet und OpenGL für alle Betriebssysteme zugänglich ist.
2. Ich bin bei der Suche nach Code auf folgende nützliche Site gestoßen: www.shadow3d.de.vu. Dort findet man jeweils den kompetten Quellcode zum Download für viele Programme. Mir hat es besonders der Terrain - Quellcode angetan, da ich gerne Outdoor-Maps durchstreife.
Gruß Pierre
|
|
Kalka
Beiträge: 33
|
Verfasst: Di 05.11.02 19:58
also ich habe das Tut gerade durchgemacht, und das war meine erste 3D Anwendung, hätte niemals gedacht, das ich das beim ersten mal ohne Probleme hinbekommen. Habe mir auch einige Befehle ganauer angeguckt und einiges hab ich halt schnell drinne gehabt weil ich mich schonmal mit ner Engine beschäftigt habe (ner fertigen;)) Mir hat das Tut geholfen
cu Kalka
|
|
Shadow
Ehemaliges Mitglied
Erhaltene Danke: 1
|
Verfasst: So 26.01.03 21:26
Titel: OHH die gutewn alten Zeiten
Hey hab mir mal gerade mein "altes" tut reingezogen, verdammt das ist lustig, weil es lange her ist.
Und die sehr Nützliche Site ist zufälliger Weise meine Homepage aber kein Hat es gemerkt, wollte nur mal sagen dass "Ich" sehr viel on diesen 8 monaten dazugelernt habe. Will damit allen nur mut machen. Also Jungs viel Spaß mit OpenGL. Und gebt nikcht auf *g*
Cya Leutz
|
|
raven_22
Beiträge: 95
Win XP pro
D7 Enterprise
|
Verfasst: So 02.01.05 16:24
Hi Leutz !
Also das Tut ist wirklich gut erklärt, zumindest für mich.
Wenn man anfängt zu programmieren, sollte man aber schon wissen wie ein Computer arbeitet.
Es gibt doch so viele Bücher und Internetseiten wo alles gut erklärt ist.
Niemand verlang dass ihr die Entstehungsgeschichte des Computers auswendig könnt.
Aber zumindest solltet ihr Kenntnisse über die Grundfunktionen der Digitaltechnik haben.
Der Rechner macht genau das, was ihr ihm sagt.
Wenn ihr ihm etwas falschen sagt, braucht ihr euch auch nicht über Fehlermeldungen und Abstürze zu wundern.
Ich würde einigen vorschlagen, erstmal mit DirectX anzufangen und dann später auf OpenGL umzusteigen.
Zumindest mache ich das so, finde ich besser.
Von Delphi steige ich dann auf C++ um.
Doch zurück zum Thema.
Früher war OpenGL mal der absolute Renner.
Damals war DirectX noch nicht so bekannt und der Funktionsumfang lies wohl auch zu wünschen übrig.
Mittlerweile scheint sich das zu ändern.
DirectX gewinnt zunehmend an Bedeutung.
Es wird mittlerweile in regelmäßigen Abstanden aktualisiert und verbessert.
Man kann fast alle paar Monate mit einer neuen Version rechnen.
OpenGL scheint immer mehr in Vergessenheit zu geraten.
Hinzu kommt, das OpenGL doch etwas komplizierter scheint als DirectX.
Soweit ich weiß ist DirectX nur unter Windows zu verwenden.
Da alternative Betriebsystem mittlerweile auf dem Vormarsch sind, müssen sich die Programmierer auch darauf einstellen.
Mir ist aufgefallen das einige Spiele, beide Schnittstellen zu unterstützen scheinen.
Das macht ja irgendwie auch sinn, finde ich.
Wenn das Spiel auf Windows läuft, dann nutz man die DirectX-Schnittstelle.
Auf allen anderen Systemen wird halt auf OpenGL umgeschaltet.
So kann man aus jedem System, die beste Leistung und schönste Grafik zaubern.
Wenn OpenGL nicht bald mit paar richtig geilen neuen Funktionen auf den Markt kommt, wird’s sicher im Schatten der 3D-Welt von DirectX verschwinden.
Microsoft müsste DirectX nur so coden, das es auch auf anderen Systemen verwendet werden kann.
Demzufolge könnte dann auch DirectX unter Linux oder Mac laufen.
Sicher arbeiten die schon lange daran, ihr Windows und DirectX auch auf andere Systeme zu portieren.
Wenn ihnen das gelingt, dann is vorbei mit Individualität.
Ich habe schon so viele Technologien kommen und wieder verschwinden gesehen.
Zuviel kann man nie können, sage ich mir immer.
Delphi, C++, DirectX und OpenGL sind sehr nützlich und leicht zu erlernen.
Für meine Zwecke recht es auf jeden Fall aus.
Ein ausgezeichnetes Beispiel für 3D-Grafik ist Half-Life 2.
Da macht das spielen auch wieder Spaß, geile Grafik.
Selbst auf meiner alten Geforce 3 TI 200, konnte ich die frühe Beta laufen lassen.
Obwohl ich Teile des damaligen Quellcodes gesehen habe, weiß ich jetzt nicht mehr ob die in OpenGL oder in DirectX gecodet haben.
Ist mir auch egal, meine Karte kann ja alles.
Half-Life und Counter sind meines wissen auch 3D-Anwendungen.
Im Softwaremodus berechnet halt die CPU das, was die Grafikkarte nicht kann.
Wobei wir wieder beim Grundwissen über Computer wären.
LG raven  _________________ ---_-= raven_22 =-_---
|
|
F34r0fTh3D4rk
Beiträge: 5284
Erhaltene Danke: 27
Win Vista (32), Win 7 (64)
Eclipse, SciTE, Lazarus
|
Verfasst: So 22.05.05 14:12
ich finde das tutorial richtig gut, leicht verständlich, jedoch habe ich einen kleinen fehler:
ich sehe den würfel nur einmal kurz aufblinken, dann ist er wieder weg, ich habe glclear auskommentiert (dann wird er ja nicht wieder gelöscht sondern immer wieder drüber gezeichnet)und ich erhalte ein seltsames pixelgitter:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
| unit Unit1;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, opengl, ExtCtrls;
type
TForm1 = class(TForm)
Timer1: TTimer;
procedure FormCreate(Sender: TObject);
procedure FormDestroy(Sender: TObject);
procedure Timer1Timer(Sender: TObject);
procedure FormResize(Sender: TObject);
private
procedure OnIdle(Sender: TObject; var Done: Boolean);
public
end;
var
Form1: TForm1;
DC: HDC;
RC: HGLRC;
FrameRate: integer;
implementation
{$R *.dfm}
procedure TForm1.FormCreate(Sender: TObject);
var
pfd: TPixelFormatDescriptor;
p: integer;
begin
Form1.Caption := 'Form1 FPS: 0';
fillchar(pfd, sizeof(pfd), 0);
DC := getDC(Form1.Handle);
pfd.cDepthBits := 16;
pfd.cColorBits := 16;
pfd.DWflags := PFD_DRAW_TO_WINDOW or PFD_SUPPORT_OPENGL or PFD_DOUBLEBUFFER;
p := choosepixelformat(DC, @pfd);
setpixelformat(DC, p, @pfd);
RC := wglCreateContext(DC);
wglMakeCurrent(DC, RC);
glClearColor(1, 1, 1, 0);
glEnable(GL_DEPTH_TEST);
Application.OnIdle := Form1.OnIdle;
end;
procedure TForm1.FormResize(Sender: TObject);
begin
glViewPort(0, 0, clientwidth,clientheight);
glMatrixMode(GL_PROJECTION);
glLoadIdentity;
gluPerspective(45, clientwidth / clientheight, 0.1, 100);
glMatrixMode(GL_MODELVIEW);
end;
procedure TForm1.onidle(Sender: TObject; var Done: Boolean);
begin
Done := false;
inc(framerate);
glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);
glTranslatef(0, 0, -5);
glColor3f(0, 0, 0);
glRotatef(4, 1, 0, 0);
glRotatef(3, 0, 1, 0);
glRotatef(2, 0, 0, 1);
glBegin(GL_QUADS);
glVertex3f(-1, -1, 1);
glVertex3f(1, -1, 1);
glVertex3f(1, 1, 1);
glVertex3f(-1, 1, 1);
glVertex3f(-1, -1, -1);
glVertex3f(-1, 1, -1);
glVertex3f(1, 1, -1);
glVertex3f(1, -1, -1);
glVertex3f( -1, 1, -1);
glVertex3f( -1, 1, 1);
glVertex3f(1, 1, 1);
glVertex3f(1, 1, -1);
glVertex3f(-1, -1, -1);
glVertex3f(1, -1, -1);
glVertex3f(1, -1, 1);
glVertex3f(-1,-1, 1);
glVertex3f(1, -1, -1);
glVertex3f(1, 1, -1);
glVertex3f(1, 1, 1);
glVertex3f(1, -1, 1);
glVertex3f(-1, -1, -1);
glVertex3f(-1, -1, 1);
glVertex3f(-1, 1, 1);
glVertex3f(-1, 1, -1);
glEnd;
SwapBuffers(DC);
end;
procedure TForm1.FormDestroy(Sender: TObject);
begin
wglMakeCurrent(DC, 0);
wglDeleteContext(RC);
releaseDC(0, DC);
end;
procedure TForm1.Timer1Timer(Sender: TObject);
begin
Form1.Caption := 'Form1 FPS: ' + inttostr(framerate);
Framerate := 0;
end;
end. |
Und was bringt das OnRezise ? außer die Größe anzupassen ?
EDIT: hab den Fehler schon gefunden, hab sleep(1000) eingebaut und gesehen, dass sich der würfel einfach nur ganz schnell wegbewegt
mein endergebnis sieht jetzt so aus:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
| unit Unit1;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, opengl, ExtCtrls;
type
TForm1 = class(TForm)
Timer1: TTimer;
Panel1: TPanel;
procedure FormCreate(Sender: TObject);
procedure FormDestroy(Sender: TObject);
procedure Timer1Timer(Sender: TObject);
procedure FormResize(Sender: TObject);
private
procedure OnIdle(Sender: TObject; var Done: Boolean);
public
end;
var
Form1: TForm1;
DC: HDC;
RC: HGLRC;
FrameRate: integer;
implementation
{$R *.dfm}
procedure TForm1.FormCreate(Sender: TObject);
var
pfd: TPixelFormatDescriptor;
p: integer;
begin
Form1.Caption := 'Form1 FPS: 0';
fillchar(pfd, sizeof(pfd), 0);
DC := getDC(Panel1.Handle);
pfd.cDepthBits := 16;
pfd.cColorBits := 16;
pfd.DWflags := PFD_DRAW_TO_WINDOW or PFD_SUPPORT_OPENGL or PFD_DOUBLEBUFFER;
p := choosepixelformat(DC, @pfd);
setpixelformat(DC, p, @pfd);
RC := wglCreateContext(DC);
wglMakeCurrent(DC, RC);
glClearColor(1, 1, 1, 0);
glEnable(GL_DEPTH_TEST);
glTranslatef(-1.5, -0.1, -5);
glRotatef(45, 1, 0, 0);
Application.OnIdle := Form1.OnIdle;
end;
procedure TForm1.FormResize(Sender: TObject);
begin
glViewPort(0, 0, clientwidth,clientheight);
glMatrixMode(GL_PROJECTION);
glLoadIdentity;
gluPerspective(45, clientwidth / clientheight, 0.1, 100);
glMatrixMode(GL_MODELVIEW);
end;
procedure TForm1.Timer1Timer(Sender: TObject);
begin
Form1.Caption := 'Form1 FPS: ' + inttostr(framerate);
Framerate := 0;
end;
procedure TForm1.onidle(Sender: TObject; var Done: Boolean);
begin
Done := false;
inc(framerate);
glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);
glRotatef(0.01, -1, -2, 0);
glBegin(GL_QUADS);
glColor3f(1, 0, 0);
glVertex3f(-1, -1, 1);
glVertex3f(1, -1, 1);
glVertex3f(1, 1, 1);
glVertex3f(-1, 1, 1);
glColor3f(0, 1, 0);
glVertex3f(-1, -1, -1);
glVertex3f(-1, 1, -1);
glVertex3f(1, 1, -1);
glVertex3f(1, -1, -1);
glColor3f(0, 0, 1);
glVertex3f( -1, 1, -1);
glVertex3f( -1, 1, 1);
glVertex3f(1, 1, 1);
glVertex3f(1, 1, -1);
glColor3f(1, 1, 0);
glVertex3f(-1, -1, -1);
glVertex3f(1, -1, -1);
glVertex3f(1, -1, 1);
glVertex3f(-1,-1, 1);
glColor3f(1, 0, 1);
glVertex3f(1, -1, -1);
glVertex3f(1, 1, -1);
glVertex3f(1, 1, 1);
glVertex3f(1, -1, 1);
glColor3f(0, 1, 1);
glVertex3f(-1, -1, -1);
glVertex3f(-1, -1, 1);
glVertex3f(-1, 1, 1);
glVertex3f(-1, 1, -1);
glEnd;
SwapBuffers(DC);
end;
procedure TForm1.FormDestroy(Sender: TObject);
begin
wglMakeCurrent(DC, 0);
wglDeleteContext(RC);
releaseDC(0, DC);
end;
end. |
Hübsch oder ?
Zuletzt bearbeitet von F34r0fTh3D4rk am So 22.05.05 14:44, insgesamt 1-mal bearbeitet
|
|
uall@ogc
Beiträge: 1826
Erhaltene Danke: 11
Win 2000 & VMware
Delphi 3 Prof, Delphi 7 Prof
|
Verfasst: So 22.05.05 14:34
und glFloat = single und nicht real
_________________ wer andern eine grube gräbt hat ein grubengrabgerät
- oder einfach zu viel zeit
|
|
F34r0fTh3D4rk
Beiträge: 5284
Erhaltene Danke: 27
Win Vista (32), Win 7 (64)
Eclipse, SciTE, Lazarus
|
Verfasst: So 22.05.05 14:40
kann ich bei dem würfel jetzt die ränder (polygonkanten) mit einem Schwarzen Strich versehen, ich möchte son kleinen comic look drinne haben
EDIT: so habs jetzt hinbekommen:
Delphi-Quelltext
1:
2:
| glLineWidth(2);
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); |
1. Aber jetzt werden die Flächen nicht mehr gezeichnet.
2. Weiß jemand wie ich die Seiten mit einer Textur(gestreckt) füllen kann ?
(ach ich mach einfach n neues topic auf ^^)
|
|
|
