Ich habe beschlossen, ein wenig über den Programmieraspekt und die Art und Weise, wie Komponenten miteinander kommunizieren, zu schreiben. Vielleicht bringt es etwas Licht in bestimmte Bereiche.
Die Präsentation
Was braucht es, um ein einzelnes Bild, das Sie in Ihrer Frage gepostet haben, auf dem Bildschirm zu zeichnen?
Es gibt viele Möglichkeiten, ein Dreieck auf dem Bildschirm zu zeichnen. Nehmen wir der Einfachheit halber an, dass keine Vertex-Puffer verwendet wurden. (Ein Scheitelpunktpuffer ist ein Speicherbereich, in dem Sie Koordinaten speichern.) Nehmen wir an, das Programm hat der Grafikverarbeitungs-Pipeline einfach jeden einzelnen Scheitelpunkt (ein Scheitelpunkt ist nur eine Koordinate im Raum) in einer Reihe mitgeteilt.
Aber bevor wir etwas zeichnen können, müssen wir zuerst ein Gerüst bauen. Wir werden später sehen, warum :
// Clear The Screen And The Depth Buffer
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Reset The Current Modelview Matrix
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
// Drawing Using Triangles
glBegin(GL_TRIANGLES);
// Red
glColor3f(1.0f,0.0f,0.0f);
// Top Of Triangle (Front)
glVertex3f( 0.0f, 1.0f, 0.0f);
// Green
glColor3f(0.0f,1.0f,0.0f);
// Left Of Triangle (Front)
glVertex3f(-1.0f,-1.0f, 1.0f);
// Blue
glColor3f(0.0f,0.0f,1.0f);
// Right Of Triangle (Front)
glVertex3f( 1.0f,-1.0f, 1.0f);
// Done Drawing
glEnd();
Also, was hat das getan?
Wenn Sie ein Programm schreiben, das die Grafikkarte verwenden möchte, wählen Sie normalerweise eine Schnittstelle zum Treiber. Einige bekannte Schnittstellen zum Treiber sind:
In diesem Beispiel bleiben wir bei OpenGL. Über die Schnittstelle zum Treiber verfügen Sie nun über alle Tools, die Sie zum Sprechen Ihres Programms mit der Grafikkarte (oder dem Treiber, der dann mit der Karte spricht ) benötigen .
Diese Schnittstelle wird Ihnen bestimmte Werkzeuge zur Verfügung stellen . Diese Tools haben die Form einer API, die Sie von Ihrem Programm aus aufrufen können.
Diese API wird im obigen Beispiel verwendet. Lass uns genauer hinschauen.
Das Gerüst
Bevor Sie wirklich zeichnen können, müssen Sie ein Setup durchführen . Sie müssen Ihr Ansichtsfenster (den Bereich, der tatsächlich gerendert wird), Ihre Perspektive (die Kamera in Ihre Welt) und das verwendete Anti-Aliasing definieren (um die Kanten Ihres Dreiecks zu glätten) ...
Aber das werden wir uns nicht ansehen. Wir werfen einen kurzen Blick auf die Dinge, die Sie für jeden Frame tun müssen . Mögen:
Bildschirm löschen
Die Grafik-Pipeline löscht nicht bei jedem Frame den Bildschirm. Du wirst es sagen müssen. Warum? Deshalb:
Wenn Sie den Bildschirm nicht löschen, werden Sie einfach über ziehen sie jeden Rahmen. Deshalb rufen wir glClearmit dem GL_COLOR_BUFFER_BITSet an. Das andere Bit ( GL_DEPTH_BUFFER_BIT) teilt OpenGL mit den löschen Tiefen Puffern. Dieser Puffer wird verwendet, um zu bestimmen, welche Pixel vor (oder hinter) anderen Pixeln liegen.
Transformation
Bildquelle
Die Transformation ist der Teil, in dem wir alle Eingabekoordinaten (die Eckpunkte unseres Dreiecks) nehmen und unsere ModelView-Matrix anwenden. Dies ist die Matrix, die erklärt, wie unser Modell (die Scheitelpunkte) gedreht, skaliert und verschoben wird.
Als nächstes wenden wir unsere Projektionsmatrix an. Dadurch werden alle Koordinaten so verschoben, dass sie korrekt auf unsere Kamera ausgerichtet sind.
Jetzt transformieren wir noch einmal mit unserer Viewport-Matrix. Wir tun dies, um unser Modell an die Größe unseres Monitors anzupassen. Jetzt haben wir eine Reihe von Scheitelpunkten, die gerendert werden können!
Wir werden etwas später auf die Transformation zurückkommen.
Zeichnung
Um ein Dreieck zu zeichnen, können wir OpenGL einfach anweisen, eine neue Liste von Dreiecken zu beginnen, indem wir glBeginmit der GL_TRIANGLESKonstante aufrufen .
Es gibt auch andere Formen, die Sie zeichnen können. Wie ein Dreiecksstreifen oder ein Dreiecksfächer . Dies sind in erster Linie Optimierungen, da sie weniger Kommunikation zwischen der CPU und der GPU erfordern, um die gleiche Anzahl von Dreiecken zu zeichnen.
Danach können wir eine Liste von Sätzen mit 3 Eckpunkten erstellen, die jedes Dreieck bilden sollen. Jedes Dreieck verwendet 3 Koordinaten (da wir uns im 3D-Raum befinden). Zusätzlich biete ich für jeden Scheitelpunkt eine Farbe an, indem ich glColor3f vor dem Aufruf aufrufe glVertex3f.
Der Schatten zwischen den drei Eckpunkten (den drei Ecken des Dreiecks) wird von OpenGL automatisch berechnet . Die Farbe wird über die gesamte Fläche des Polygons interpoliert.
Interaktion
Nun, wenn Sie auf das Fenster klicken. Die Anwendung muss nur die Fenstermeldung erfassen, die den Klick signalisiert. Anschließend können Sie eine beliebige Aktion in Ihrem Programm ausführen.
Dies wird sehr viel schwieriger, wenn Sie mit Ihrer 3D-Szene interagieren möchten.
Sie müssen zunächst genau wissen, bei welchem Pixel der Benutzer auf das Fenster geklickt hat. Unter Berücksichtigung Ihrer Perspektive können Sie dann die Richtung eines Strahls vom Mausklickpunkt in Ihre Szene berechnen. Sie können dann berechnen, ob ein Objekt in Ihrer Szene diesen Strahl schneidet . Jetzt wissen Sie, ob der Benutzer auf ein Objekt geklickt hat.
Also, wie lässt du es drehen?
Transformation
Mir sind zwei Arten von Transformationen bekannt, die im Allgemeinen angewendet werden:
- Matrixbasierte Transformation
- Knochenbasierte Transformation
Der Unterschied besteht darin, dass Knochen einzelne Scheitelpunkte betreffen . Matrizen wirken sich immer auf alle gezeichneten Scheitelpunkte gleich aus. Schauen wir uns ein Beispiel an.
Beispiel
Zuvor haben wir unsere Identitätsmatrix geladen , bevor wir unser Dreieck gezeichnet haben. Die Identitätsmatrix bietet einfach überhaupt keine Transformation . Was auch immer ich zeichne, wird nur von meiner Perspektive beeinflusst. Das Dreieck wird also überhaupt nicht gedreht.
Wenn ich es jetzt drehen möchte, könnte ich entweder selbst rechnen (auf der CPU) und einfach glVertex3fmit anderen Koordinaten aufrufen (die gedreht werden). Oder ich lasse die GPU die ganze Arbeit machen, indem ich glRotatefvor dem Zeichnen anrufe:
// Rotate The Triangle On The Y axis
glRotatef(amount,0.0f,1.0f,0.0f);
amountist natürlich nur ein fester Wert. Wenn Sie animieren möchten , müssen amountSie jedes Bild im Auge behalten und vergrößern.
Also, warte, was ist mit all dem Matrix-Gerede früher passiert?
In diesem einfachen Beispiel müssen wir uns nicht um Matrizen kümmern. Wir rufen einfach an glRotatefund das alles erledigt es für uns.
glRotateerzeugt eine Drehung von angleGrad um den Vektor xyz. Die aktuelle Matrix (siehe glMatrixMode ) wird mit einer Rotationsmatrix multipliziert, wobei das Produkt die aktuelle Matrix ersetzt, als würde glMultMatrix mit der folgenden Matrix als Argument aufgerufen:
x 2 ≤ 1 - c + cx ≤ y ≤ 1 - c - z ≤ sx ≤ z ≤ 1 - c + y ≤ s 0 y ≤ x ≤ 1 - c + z ≤ sy 2 ≤ 1 - c + cy ≤ z ≤ 1 - c - x s 0 x z 1 - c - y sy z 1 - c + x sz 2 1 - c + c 0 0 0 1
Danke dafür!
Fazit
Was offensichtlich wird , ist es viel Gerede ist zu OpenGL. Aber es sagt uns nichts. Wo ist die Kommunikation?
Das einzige, was uns OpenGL in diesem Beispiel sagt, ist, wenn es fertig ist . Jede Operation benötigt eine gewisse Zeit. Einige Operationen dauern unglaublich lange, andere sind unglaublich schnell.
Das Senden eines Scheitelpunkts an die GPU geht so schnell, dass ich nicht einmal weiß, wie ich ihn ausdrücken soll. Das Senden von Tausenden von Eckpunkten von der CPU an die GPU in jedem einzelnen Frame ist höchstwahrscheinlich überhaupt kein Problem.
Das Löschen des Bildschirms kann eine Millisekunde oder noch schlimmer dauern (denken Sie daran, dass Sie normalerweise nur etwa 16 Millisekunden Zeit haben, um jeden Frame zu zeichnen), je nachdem, wie groß Ihr Ansichtsfenster ist. Um es zu löschen, muss OpenGL jedes einzelne Pixel in der Farbe zeichnen, die Sie löschen möchten, das können Millionen Pixel sein.
Ansonsten können wir OpenGL so ziemlich nur nach den Fähigkeiten unserer Grafikkarte fragen (maximale Auflösung, maximales Anti-Aliasing, maximale Farbtiefe, ...).
Wir können eine Textur aber auch mit Pixeln füllen, die jeweils eine bestimmte Farbe haben. Jedes Pixel enthält somit einen Wert und die Textur ist eine riesige "Datei", die mit Daten gefüllt ist. Wir können das in die Grafikkarte laden (indem wir einen Texturpuffer erstellen), dann einen Shader laden , diesen Shader anweisen, unsere Textur als Eingabe zu verwenden, und einige extrem schwere Berechnungen für unsere "Datei" ausführen.
Wir können dann das Ergebnis unserer Berechnung (in Form neuer Farben) in eine neue Textur "rendern".
Auf diese Weise können Sie die GPU auf andere Weise für Sie arbeiten lassen. Ich gehe davon aus, dass CUDA ähnlich abschneidet, aber ich hatte nie die Gelegenheit, damit zu arbeiten.
Wir haben das ganze Thema wirklich nur wenig angerührt. Die Programmierung von 3D-Grafiken ist eine Hölle für sich.
Bildquelle
